celai 0.1.0__tar.gz

celai-0.1.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.1
+Name: celai
+Version: 0.1.0
+Summary: 
+Author: Alex Martin
+Author-email: alejamp@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: aiogram (>=3.6.0)
+Requires-Dist: aioredis (>=2.0.1)
+Requires-Dist: beautifulsoup4 (>=4.12.3)
+Requires-Dist: chardet (>=5.2.0)
+Requires-Dist: chromadb (>=0.5.0)
+Requires-Dist: deepgram-sdk (>=3.2.7)
+Requires-Dist: dictdiffer (>=0.9.0)
+Requires-Dist: diskcache (>=5.6.3)
+Requires-Dist: fakeredis (>=2.23.2)
+Requires-Dist: geopy (>=2.4.1)
+Requires-Dist: halo (>=0.0.31)
+Requires-Dist: langchain (>=0.2.0)
+Requires-Dist: langchain-chroma (>=0.1.1)
+Requires-Dist: langchain-community (>=0.2.1)
+Requires-Dist: langchain-openai (>=0.1.8)
+Requires-Dist: loguru (>=0.7.2)
+Requires-Dist: lxml (>=5.2.2)
+Requires-Dist: marko (>=2.1.0,<3.0.0)
+Requires-Dist: numpy (>=1.26.4,<2.0.0)
+Requires-Dist: openai (>=1.30.1)
+Requires-Dist: openai-responses (>=0.3.2)
+Requires-Dist: pybars3 (>=0.9.7)
+Requires-Dist: pysbd (>=0.3.4)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: redis (>=4.6.0)
+Requires-Dist: shortuuid (>=1.0.13)
+Project-URL: Homepage, https://github.com/cel-ai/celai
+Project-URL: Issues, https://github.com/cel-ai/celai/issues
+Description-Content-Type: text/markdown
+
+<!-- A centered logo of celia -->
+<p align="center">
+  <img src="cel/assets/celia_logo.png" width="250" />
+</p>
+
+# Introduction
+
+
+Cel.ai is a powerful Python framework designed to accelerate the development of omnichannel virtual assistants. Whether you need to integrate with platforms like WhatsApp, Telegram, or VoIP services such as VAPI.com, Cel.ai provides the tools and flexibility to get your assistant up and running quickly.
+
+
+## Install
+
+pip install from github:
+```bash
+pip install git+https://github.com/cel-ai/celai
+```
+## Getting Started
+
+Create a new Python file, `assistant.py`, and open it in your favorite text editor. Add the following code to set up a basic assistant:
+
+
+```python
+# Import Cel.ai modules
+from cel.connectors.cli.cli_connector import CliConnector
+from cel.gateway.message_gateway import MessageGateway, StreamMode
+from cel.message_enhancers.smart_message_enhancer_openai import SmartMessageEnhancerOpenAI
+from cel.assistants.macaw.macaw_assistant import MacawAssistant
+from cel.prompt.prompt_template import PromptTemplate
+
+# Setup prompt
+prompt = """You are an AI assistant. Called Celia. You can help a user to buy Bitcoins."""
+prompt_template = PromptTemplate(prompt)
+
+# Create the assistant based on the Macaw Assistant 
+ast = MacawAssistant(
+    prompt=prompt_template
+)
+
+# Create the Message Gateway - This component is the core of the assistant
+# It handles the communication between the assistant and the connectors
+gateway = MessageGateway(ast)
+
+# For this example, we will use the CLI connector
+conn = CliConnector(
+    stream_mode=StreamMode.FULL
+)
+# Register the connector with the gateway
+gateway.register_connector(conn)
+
+# Then start the gateway and begin processing messages
+gateway.run()
+```

celai-0.1.0/README.md

@@ -0,0 +1,53 @@
+<!-- A centered logo of celia -->
+<p align="center">
+  <img src="cel/assets/celia_logo.png" width="250" />
+</p>
+
+# Introduction
+
+
+Cel.ai is a powerful Python framework designed to accelerate the development of omnichannel virtual assistants. Whether you need to integrate with platforms like WhatsApp, Telegram, or VoIP services such as VAPI.com, Cel.ai provides the tools and flexibility to get your assistant up and running quickly.
+
+
+## Install
+
+pip install from github:
+```bash
+pip install git+https://github.com/cel-ai/celai
+```
+## Getting Started
+
+Create a new Python file, `assistant.py`, and open it in your favorite text editor. Add the following code to set up a basic assistant:
+
+
+```python
+# Import Cel.ai modules
+from cel.connectors.cli.cli_connector import CliConnector
+from cel.gateway.message_gateway import MessageGateway, StreamMode
+from cel.message_enhancers.smart_message_enhancer_openai import SmartMessageEnhancerOpenAI
+from cel.assistants.macaw.macaw_assistant import MacawAssistant
+from cel.prompt.prompt_template import PromptTemplate
+
+# Setup prompt
+prompt = """You are an AI assistant. Called Celia. You can help a user to buy Bitcoins."""
+prompt_template = PromptTemplate(prompt)
+
+# Create the assistant based on the Macaw Assistant 
+ast = MacawAssistant(
+    prompt=prompt_template
+)
+
+# Create the Message Gateway - This component is the core of the assistant
+# It handles the communication between the assistant and the connectors
+gateway = MessageGateway(ast)
+
+# For this example, we will use the CLI connector
+conn = CliConnector(
+    stream_mode=StreamMode.FULL
+)
+# Register the connector with the gateway
+gateway.register_connector(conn)
+
+# Then start the gateway and begin processing messages
+gateway.run()
+```

celai-0.1.0/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
+    
+        

celai-0.1.0/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

celai-0.1.0/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)

celai-0.1.0/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
+    
+    

celai-0.1.0/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"}))