celai 0.1.0__py3-none-any.whl

cel/assistants/base_assistant.py

@@ -0,0 +1,227 @@
+from abc import ABC, abstractmethod
+import inspect
+
+from loguru import logger as log
+from cel.assistants.function_context import FunctionContext
+from cel.assistants.function_response import FunctionResponse
+from cel.gateway.model.base_connector import BaseConnector
+from cel.assistants.common import EventResponse, FunctionDefinition
+from cel.gateway.model.message import Message, ConversationLead
+from cel.prompt.prompt_template import PromptTemplate
+from cel.rag.providers.rag_retriever import RAGRetriever
+
+
+class Events:
+    START: str = "start"
+    NEW_MESSAGE: str = "new_message"
+    IMAGE: str = "image"
+    AUDIO: str = "audio"
+    END: str = "end"
+
+class BaseAssistant(ABC):
+    
+    def __init__(self, prompt: PromptTemplate = None):
+
+        self.function_handlers = {}
+        self.event_handlers = {}
+        self.client_commands_handlers = {}
+        self.timeout_handlers = {}
+        self.rag_retriever: RAGRetriever = None
+        if prompt:
+            assert isinstance(prompt, PromptTemplate), "prompt must be an instance of PromptTemplate"
+        self.prompt = prompt or PromptTemplate('')
+
+            
+            
+    def set_rag_retrieval(self, rag_retrieval: RAGRetriever):
+        # check type
+        assert isinstance(rag_retrieval, RAGRetriever), "rag_retrieval must be an instance of RAGRetriever"
+        self.rag_retriever = rag_retrieval
+        
+
+    def function(self, name, desc, params):
+        def decorator(func):
+            self.function_handlers[name] = {
+                # 'desc': desc,
+                # 'params': params,
+                'definition': FunctionDefinition(name=name, description=desc, parameters=params),
+                'func': func
+            }
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)          
+                
+            return wrapper
+        return decorator    
+        
+        
+    def event(self, name: Events | str):
+        def decorator(func):
+            self.event_handlers[name] = {
+                'func': func
+            }
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)          
+                
+            return wrapper
+        return decorator
+    
+    
+    def client_command(self, name):
+        def decorator(func):
+            self.client_commands_handlers[name] = {
+                'func': func
+            }
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)          
+                
+            return wrapper
+        return decorator
+    
+    def timeout(self, label):
+        def decorator(func):
+            self.timeout_handlers[label] = {
+                'func': func
+            }
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)          
+                
+            return wrapper
+        return decorator
+    
+    async def eval_client_command(self, command: str, args: list[str], message: Message):
+        """Evaluate the client command and call the respective handler"""
+        lead = message.lead
+        connector = lead.connector
+        
+        if command in self.client_commands_handlers:
+            func = self.client_commands_handlers[command]['func']
+            # Build args_dict
+            from cel.gateway.request_context import RequestContext
+            ctx = RequestContext(lead=lead, 
+                                 connector=connector,
+                                 assistant=self)
+            args_dict = {
+                'session': lead.get_session_id(),
+                'ctx': ctx,
+                'lead': lead,
+                'message': None,
+                'connector': connector,
+                'command': command,
+                'args': args
+            }
+            
+            # Build kwargs using args and args_dict
+            args = inspect.getfullargspec(func).args
+            kwargs = {}
+            for arg in args:
+                if arg in args_dict:
+                    kwargs[arg] = args_dict[arg]
+
+            # Check if the function is a coroutine (async function)
+            if inspect.iscoroutinefunction(func):
+                await func(**kwargs)
+            else:
+                func(**kwargs)      
+            return False
+        else:
+            log.warning(f"Client command {command} not found in assistant implementation")
+            return True
+    
+    async def call_event(self, event_name: str, lead: ConversationLead, message: Message = None, connector: BaseConnector = None, data: dict= None) -> EventResponse:
+        """Call the respective event handler, if exists"""
+        if event_name in self.event_handlers:
+            func = self.event_handlers[event_name]['func']
+            connector = connector or lead.connector
+            from cel.gateway.request_context import RequestContext
+            ctx = RequestContext(lead=lead, 
+                                 message=message,
+                                 assistant=self,
+                                 connector=connector)
+            
+            # Build args_dict
+            args_dict = {
+                'session': lead.get_session_id(),
+                'ctx': ctx,
+                'lead': lead,
+                'message': message,
+                'connector': connector,
+                'data': data
+            }
+            
+            # Build kwargs using args and args_dict
+            args = inspect.getfullargspec(func).args
+            kwargs = {}
+            for arg in args:
+                if arg in args_dict:
+                    kwargs[arg] = args_dict[arg]
+
+            # Check if the function is a coroutine (async function)
+            response = None
+            if inspect.iscoroutinefunction(func):
+                response = await func(**kwargs)
+            else:
+                response = func(**kwargs)    
+                
+            assert isinstance(response, EventResponse) or response is None, "Event handler must return an instance of EventResponse or None"
+            return response
+        else:
+            # raise ValueError(f"Event {event_name} not found")
+            log.error(f"Event {event_name} not found")
+        
+    
+    async def call_function(self, func_name: str, params: dict, lead: ConversationLead) -> FunctionResponse:
+        """Call the respective function handler, if exists. Map function arguments to the function handler signature"""
+        connector = lead.connector
+        if func_name in self.function_handlers:
+            func = self.function_handlers[func_name]['func']
+            args = inspect.getfullargspec(func).args
+
+            ctx = FunctionContext(lead=lead, connector=connector)
+            args_dict = {
+                'session': lead.get_session_id(),
+                'ctx': ctx,
+                'params': params,
+                'lead': lead,
+                'message': None,
+                'connector': connector
+            }
+
+            # Build kwargs using args and args_dict
+            kwargs = {}
+            for arg in args:
+                if arg in args_dict:
+                    kwargs[arg] = args_dict[arg]
+
+            # Check if the function is a coroutine (async function)
+            response = None
+            if inspect.iscoroutinefunction(func):
+                response = await func(**kwargs)
+            else:
+                response = func(**kwargs)
+                
+            assert isinstance(response, FunctionResponse) or response is None, "Function handler must return an instance of CommandResponse or None"
+            return response
+        
+        else:
+            raise ValueError(f"Function {func_name} not found")
+            
+    @abstractmethod
+    async def new_message(self, lead: ConversationLead, message: str, local_state: dict = {}):
+        raise NotImplementedError
+    
+    
+    @abstractmethod
+    async def blend(self, lead: ConversationLead, text: str, history_length: int = 3):
+        raise NotImplementedError
+    
+    @abstractmethod
+    async def process_client_command(self, lead: ConversationLead, command: str, args: list[str]):
+        yield "Command not found"
+    
+    def get_functions(self) -> list[FunctionDefinition]:
+       return [f['definition'] for f in self.function_handlers.values()] 
+
+    def get_events(self):
+        return self.event_handlers
+    
+        

cel/assistants/common.py

@@ -0,0 +1,28 @@
+
+from abc import ABC
+from dataclasses import dataclass
+
+
+@dataclass
+class Param(ABC):
+    name: str
+    type: str
+    description: str
+    required: bool = True
+    enum: list[str] = None
+
+@dataclass
+class FunctionDefinition(ABC):
+    name: str
+    description: str
+    parameters: list[Param]
+
+@dataclass
+class EventResponse(ABC):
+    text: str = None
+    image: str = None
+    audio: str = None
+    video: str = None
+    disable_ai_response: bool = False
+    blend: bool = False
+    is_private: bool = False

cel/assistants/function_context.py

@@ -0,0 +1,24 @@
+from cel.assistants.function_response import FunctionResponse, RequestMode
+from cel.gateway.model.base_connector import BaseConnector
+from cel.gateway.model.message import ConversationLead, Message
+
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class FunctionContext:
+    lead: ConversationLead
+    message: Message | None = None
+    connector: BaseConnector | None = None
+    state: dict | None = field(default_factory=dict)
+    history: list[dict] | None = field(default_factory=list)
+
+    @staticmethod
+    def response_text(text: str, request_mode: RequestMode = RequestMode.SINGLE):
+        return FunctionResponse(text=text, request_mode=request_mode)
+
+    
+    # @staticmethod
+    # def response_image(image_url: str, request_mode: RequestMode = RequestMode.SINGLE):
+    #     return FunctionResponse(image_url=image_url, request_mode=request_mode)

cel/assistants/function_response.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from typing import Callable
+
+
+class RequestMode:
+    STREAM = "stream"
+    SINGLE = "single"
+
+
+@dataclass
+class FunctionResponse:
+    text: str
+
+    """ the execution function response will be sent as a stream of chunks or as a single response """
+    request_mode: str = RequestMode.SINGLE
+
+    """ If you want to disable direct response from Asiistant AI, use callback to handle the response.
+    It is useful when you want to handle the response in a different way, like sending the response to a different service.
+    Another use case is when oyu need to use specific platform features to send the response, like interactives messages, buttons, etc.
+    """
+    callback: Callable = None
+    
+    

cel/assistants/macaw/custom_chat_models/chat_open_router.py

@@ -0,0 +1,53 @@
+# https://medium.com/@gal.peretz/openrouter-langchain-leverage-opensource-models-without-the-ops-hassle-9ffbf0016da7
+
+import os
+from typing import Optional
+from langchain_community.chat_models import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+
+
+OPENROUTER_API_BASE = "https://openrouter.ai/api/v1"
+
+
+# TODO: OpenRouter Models has problems with Langchain tooling
+# This LLM model wrapper throws an error when used with Langchain tooling
+# specifically with bind_tools. The error is due to the fact that the
+# OpenRouter models do not support tooling??? I am not sure about this.
+# --------------------------------------------------------------------
+class ChatOpenRouter(ChatOpenAI):
+    openai_api_base: str
+    openai_api_key: str
+    model_name: str
+
+    def __init__(self,
+                 model: str,
+                 openai_api_key: Optional[str] = None,
+                 openai_api_base: str = OPENROUTER_API_BASE,
+                 **kwargs):
+        openai_api_key = openai_api_key or os.getenv('OPENROUTER_API_KEY')
+        super().__init__(openai_api_base=openai_api_base,
+                         openai_api_key=openai_api_key,
+                         model_name=model, **kwargs)
+        
+      
+def ChatOpenAIOpenRouter(**kwargs):
+    return ChatOpenAI(
+        **kwargs, 
+        openai_api_base=OPENROUTER_API_BASE,
+        openai_api_key = os.getenv('OPENROUTER_API_KEY')
+    )
+# --------------------------------------------------------------------
+        
+        
+# if __name__ == '__main__':
+    
+#     # Load .env variables
+#     from dotenv import load_dotenv
+#     load_dotenv()
+    
+#     llm = ChatOpenRouter(
+#         model="mistralai/mixtral-8x7b-instruct"
+#     )
+#     prompt = ChatPromptTemplate.from_template("tell me a short joke about {topic}")
+#     openrouter_chain = prompt | llm
+#     print(openrouter_chain.invoke({"topic": "banana"}))

cel/assistants/macaw/macaw_assistant.py

@@ -0,0 +1,203 @@
+import json
+from loguru import logger as log
+from cel.assistants.base_assistant import BaseAssistant
+from cel.assistants.macaw.macaw_inference_context import MacawNlpInferenceContext
+from cel.assistants.macaw.macaw_nlp import MacawFunctionCall, blend_message, process_insights, process_new_message
+from cel.assistants.macaw.macaw_settings import MacawSettings
+from cel.gateway.model.conversation_lead import ConversationLead
+from cel.prompt.prompt_template import PromptTemplate
+from cel.stores.history.base_history_provider import BaseHistoryProvider
+from cel.stores.history.history_inmemory_provider import InMemoryHistoryProvider
+from cel.stores.state.base_state_provider import BaseChatStateProvider
+from cel.stores.state.state_inmemory_provider import InMemoryStateProvider
+from langchain.load.load import loads, load
+from langchain.load.dump import dumps
+
+
+class MacawAssistant(BaseAssistant):
+    """Macaw Assistant is a conversational assistant that uses Langchain as core NLP.
+    This assistant perform different NLP tasks like blending, insights, and more.
+    To perform these tasks, Macaw Assistant uses differents models and tools. You can
+    configure the assistant with different settings and tools for each task.
+    
+    If you use this assistant make sure to setup your LLM API key in the environment variable:
+        - OPENAI_API_KEY: The OpenAI API key for the assistant.
+    
+    Tasks:
+        - Blending: Blend a message with the current context.
+        - Insights: Get insights from the current context.
+        - Process new message: Process a new message with the current context and return the response.
+
+    Args:
+        state (dict, optional): Initial state for the assistant. Defaults to None.
+        history_store (BaseHistoryProvider, optional): History store provider. Defaults to None.
+        state_store (BaseChatStateProvider, optional): State store provider. Defaults to None.
+        prompt (PromptTemplate, optional): Prompt template for the assistant. Defaults to None.
+        insight_targets (dict, optional): Insight targets for the assistant. Defaults to {}.
+        settings (MacawSettings, optional): Settings for the assistant. Defaults to None.
+
+    """
+    
+    def __init__(self, 
+                 state: dict = None,
+                 history_store:BaseHistoryProvider=None, 
+                 state_store: BaseChatStateProvider=None,
+                 prompt: PromptTemplate = None,
+                 insight_targets: dict = {},
+                 settings: MacawSettings = None,
+                 llm=None,
+                ):
+        
+        super().__init__(prompt=prompt)
+        self.state = state or {}
+        self.insight_targets = insight_targets
+        self._state_store = state_store or InMemoryStateProvider()
+        self._history_store = history_store or InMemoryHistoryProvider()
+        if settings is None:
+            log.warning("No settings provided for Macaw Assistant, using default settings")
+        self.settings = settings or MacawSettings()
+        self.llm = llm
+        log.debug(f"Macaw Assistant initialized with settings: {self.settings}")
+        
+
+    async def new_message(self, lead: ConversationLead, message: str, local_state: dict = {}):
+        # create context
+        ctx = MacawNlpInferenceContext(
+            lead=lead,
+            prompt=self.prompt,
+            init_state=self.state,
+            local_state=local_state,
+            functions=self.get_functions(),
+            history_store=self._history_store,
+            state_store=self._state_store,
+            settings=self.settings,
+            rag_retriever=self.rag_retriever,
+            llm=self.llm
+        )
+        
+        async def on_function_call(ctx: MacawNlpInferenceContext, call: MacawFunctionCall):
+            return await self.call_function(
+                    func_name=call.name,
+                    params=call.args,
+                    lead=ctx.lead
+                )
+        try:
+            # stream this message content from string
+            async for chunk in process_new_message(ctx, message, on_function_call):
+                yield chunk
+    
+        except Exception as e:
+            log.error(f"Macaw Assistant: error processing new message: {e}")
+        
+
+    async def blend(self, lead: ConversationLead, text: str, history_length: int = None):
+        # create context
+        ctx = MacawNlpInferenceContext(
+            lead=lead,
+            prompt=self.prompt,
+            init_state=self.state,
+            local_state={},
+            history_store=self._history_store,
+            state_store=self._state_store,
+            settings=self.settings
+        )
+        
+        
+        return await blend_message(ctx, message=text)
+    
+    async def do_insights(self, lead: ConversationLead, targets: dict = {}, history_length: int = 10):
+        assert isinstance(targets, dict), "targets must be a dictionary"
+        
+        if self.settings.insights_enabled is False:
+            log.warning("Insights are disabled, returning None")
+            return None
+        
+        log.debug(f"Getting insights for lead: {lead} with targets: {targets}")
+        
+        mix_targets = {**self.insight_targets, **targets}
+        
+        # create context
+        ctx = MacawNlpInferenceContext(
+            lead=lead,
+            prompt=self.prompt,
+            init_state=self.state,
+            local_state={},
+            history_store=self._history_store,
+            state_store=self._state_store,
+            settings=self.settings
+        )
+        
+        insights = await process_insights(ctx, targets=mix_targets)
+        
+        # raise insight event
+        await self.call_event("insigths", lead, data=insights)
+        return insights
+        
+    
+    async def process_client_command(self, lead: ConversationLead, command: str, args: list[str]):
+    
+        if command == "reset":
+            
+            if args and args[0] == "all":
+                await self._history_store.clear_history(lead.get_session_id())
+                yield "History cleared"
+                self._state_store.set_store(lead.get_session_id(), {})
+                yield "State cleared"
+                return
+
+            await self._history_store.clear_history(lead.get_session_id())
+            yield "History cleared"
+            return
+        
+        if command == "state":
+            state = self._state_store.get_store(lead.get_session_id())
+            if state is None:
+                yield "No state found"
+                return
+            for k, v in state.items():
+                yield f"{k}: {v}"
+            return
+        
+        if command == "history":
+            history = await self._history_store.get_history(lead.get_session_id()) or []    
+
+            if history is None or len(history) == 0:
+                yield "History is empty"
+                return
+
+            for h in history:
+                aux = load(h)
+                log.debug(f"History: {aux}")
+                yield dumps(aux)
+            
+            return
+        
+        if command == "set":
+            if len(args) < 2:
+                yield "Not enough arguments"
+                return
+            key = args[0]
+            value = args[1]
+            state = self._state_store.get_store(lead.get_session_id())
+            state[key] = value
+            self._state_store.set_store(lead.get_session_id(), state)
+            yield f"State updated: {key}: {value}"
+            return
+        
+        if command == "prompt":
+            yield "Macaw Assistant v0.1"
+
+            if args and args[0] == "all":            
+                prompt = self.prompt
+                # split into 250 chars aprox chunks
+                for i in range(0, len(prompt), 250):
+                    yield prompt[i:i+250]
+                return
+            
+            # first 250 chars
+            yield self.prompt[:250]
+            return
+            
+            
+            
+            

cel/assistants/macaw/macaw_history_adapter.py

@@ -0,0 +1,33 @@
+from cel.gateway.model.conversation_lead import ConversationLead
+from langchain.load.dump import dumpd
+from langchain.load.load import load
+from langchain_core.messages import BaseMessage
+from cel.stores.history.base_history_provider import BaseHistoryProvider
+
+
+class MacawHistoryAdapter:
+    def __init__(self, store: BaseHistoryProvider):
+        self.store = store
+
+    async def append_to_history(self, lead: ConversationLead, entry: BaseMessage, metadata=None, ttl=None):
+        assert isinstance(lead, ConversationLead), f"Expected ConversationLead, got {type (lead)}"
+        aux = dumpd(entry)
+        await self.store.append_to_history(lead.get_session_id(), aux, metadata, ttl)
+
+    async def get_history(self, lead: ConversationLead) -> list[BaseMessage]:
+        assert isinstance(lead, ConversationLead), f"Expected ConversationLead, got {type (lead)}"
+        history = await self.store.get_history(lead.get_session_id())
+        return [load(h) for h in history]
+
+
+    async def clear_history(self, lead: ConversationLead, keep_last_messages=None):
+        assert isinstance(lead, ConversationLead), f"Expected ConversationLead, got {type (lead)}"
+        await self.store.clear_history(lead.get_session_id(), keep_last_messages)
+
+    async def get_last_messages(self, lead: ConversationLead, count) -> list[BaseMessage]:
+        assert isinstance(lead, ConversationLead), f"Expected ConversationLead, got {type (lead)}"
+        msgs = await self.store.get_last_messages(lead.get_session_id(), count)
+        return [load(m) for m in msgs]
+
+    async def close_conversation(self, lead: ConversationLead):
+        raise NotImplementedError

cel/assistants/macaw/macaw_inference_context.py

@@ -0,0 +1,28 @@
+from cel.assistants.common import FunctionDefinition
+from cel.assistants.macaw.macaw_settings import MacawSettings
+from cel.gateway.model.conversation_lead import ConversationLead
+from cel.prompt.prompt_template import PromptTemplate
+from cel.rag.providers.rag_retriever import RAGRetriever
+from cel.stores.history.base_history_provider import BaseHistoryProvider
+from cel.stores.state.base_state_provider import BaseChatStateProvider
+
+
+from abc import ABC
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class MacawNlpInferenceContext(ABC):
+    lead: ConversationLead
+    settings: MacawSettings
+    prompt: PromptTemplate = ''
+    init_state: dict = None
+    local_state: dict = None
+    functions: list[FunctionDefinition] = None
+    rag_retriever: RAGRetriever = None
+    # default value {} is used to avoid mutable default arguments
+    llm_kwargs: dict[str, Any] = None
+    history_store: BaseHistoryProvider = None
+    state_store: BaseChatStateProvider = None
+    llm: Any = None