manolo-bot 0.1.0__py3-none-any.whl

manolo_bot/ai/config.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class BotConfig:
+    bot_uuid: str
+    bot_name: str
+    bot_username: str
+    bot_token: str
+    user_id: int
+    agent_instructions: str | None = None
+
+    allowed_chat_ids: list = field(default_factory=list)
+    bot_instructions: str = ""
+    bot_instructions_character: str = ""
+    bot_instructions_extra: str = ""
+
+    simulate_typing: bool = True
+    simulate_typing_wpm: int = 100
+    simulate_typing_max_time: int = 10
+
+    use_tools: bool = False
+
+    # MCP Configuration
+    enable_mcp: bool = False
+    mcp_servers_config: dict = field(default_factory=dict)
+
+    context_max_tokens: int = 4096
+    preferred_language: str = "English"
+    add_no_answer: bool = False
+    is_image_multimodal: bool = False
+    is_audio_multimodal: bool = False
+    is_group_assistant: bool = False
+    agent_mode: bool = False
+
+    # Web content retrieval configuration
+    web_content_request_timeout: int = 10
+
+    can_use_tavily_search: bool = False
+
+    # Stable Diffusion configuration
+    sdapi_url: str = ""
+    sdapi_params: dict = field(default_factory=dict)
+    sdapi_negative_prompt: str = ""
+
+
+@dataclass
+class LLMConfig:
+    google_api_key: str
+    google_api_model: str
+    openai_api_key: str
+    openai_api_model: str
+    openai_api_base_url: str
+    ollama_model: str
+
+    rate_limiter_requests_per_second: float = 0.25
+    rate_limiter_check_every_n_seconds: float = 0.1
+    rate_limiter_max_bucket_size: int = 10

manolo_bot/ai/llmagent.py

@@ -0,0 +1,172 @@
+import base64
+import logging
+
+import aiohttp
+from langchain.agents import create_agent
+from langchain_core.language_models import BaseChatModel
+from langchain_core.messages import BaseMessage, HumanMessage
+from langchain_core.tools import BaseTool
+
+from manolo_bot.ai.config import BotConfig
+from manolo_bot.ai.llmbot import LLMBot
+from manolo_bot.storage.base import BaseMessagesStorage
+
+
+class LLMAgent(LLMBot):
+    """
+    Advanced Telegram LLM Chat Bot using a LangGraph-based agent.
+
+    This bot can use tools and dynamically integrate with MCP servers.
+    """
+
+    bind_tools_on_init = False
+
+    def __init__(
+        self,
+        llm: BaseChatModel,
+        bot_config: BotConfig,
+        system_instructions: list[BaseMessage],
+        messages_storage: BaseMessagesStorage,
+        tools: list[BaseTool] | None = None,
+    ) -> None:
+        super().__init__(llm, bot_config, system_instructions, messages_storage, tools=tools)
+        # Don't create agent yet - wait for async initialization
+        self.agent = None
+
+    async def initialize_async_resources(self) -> None:
+        """Initialize async resources and create agent with all tools."""
+        await super().initialize_async_resources()
+
+        # Create agent with all tools (custom + MCP)
+        from manolo_bot.ai.tools import get_all_tools
+
+        # Use the tools passed in __init__ if available, otherwise get default ones
+        tools = await get_all_tools(self._mcp_manager, self.bot_config, custom_tools=self.tools)
+
+        self.agent = create_agent(
+            model=self.llm,
+            tools=tools,
+        )
+        logging.debug(f"Agent created with {len(tools)} tools")
+
+    # is probably better to not use the agent for this
+    # def generate_feedback_message(self, prompt: str, max_length: int = 200) -> str:
+    #     logging.debug("Generating feedback message")
+    #
+    #     response = self.agent.invoke({"messages": [{"role": "user", "content": prompt}]})
+    #
+    #     # Clean up the response if needed
+    #     feedback_message = response["messages"][-1].content.strip()
+    #
+    #     # Ensure the message isn't too long
+    #     if len(feedback_message) > max_length:
+    #         feedback_message = feedback_message[: max_length - 3] + "..."
+    #
+    #     logging.debug(f"Generated feedback message: {feedback_message}")
+    #     return feedback_message
+
+    async def answer_message(self, chat_id: int, message: str) -> BaseMessage:
+        self.messages_storage.add_message(HumanMessage(content=message))
+        self.truncate_chat_context()
+
+        config = self._get_langchain_config(chat_id)
+        ai_msg = await self.agent.ainvoke(
+            {"messages": self.system_instructions + self.messages_storage.messages},
+            config=config,
+        )
+        return ai_msg["messages"][-1]
+
+    async def answer_image_message(self, chat_id: int, text: str, image: str) -> BaseMessage:
+        """
+        Answer an image message.
+        :param chat_id: Chat ID
+        :param text: Text to answer
+        :param image: Image to answer
+        :return: Response
+        """
+        logging.debug(f"Image message: {text}")
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                timeout = self._get_session_timeout()
+
+                async with session.get(image, timeout=timeout) as response:
+                    response.raise_for_status()
+                    image_bytes = await response.read()
+                    image_data = base64.b64encode(image_bytes).decode("utf-8")
+
+                llm_message = HumanMessage(
+                    content=[
+                        {
+                            "type": "text",
+                            "text": text,
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
+                        },
+                    ]
+                )
+                self.messages_storage.add_message(llm_message)
+                self.truncate_chat_context()
+                config = self._get_langchain_config(chat_id)
+                response = (await self.agent.ainvoke({"messages": self.messages_storage.messages}, config=config))[
+                    "messages"
+                ][-1]
+        except (aiohttp.ClientError, Exception) as e:
+            if isinstance(e, aiohttp.ClientError):
+                logging.error(f"Failed to get image: {image}")
+            logging.exception(e)
+            response = BaseMessage(content="NO_ANSWER", type="text")
+
+        logging.debug(f"Image message response: {response}")
+        return response
+
+    async def answer_voice_message(self, chat_id: int, text: str, audio: str) -> BaseMessage:
+        """
+        Answer a voice message.
+        :param chat_id: Chat ID
+        :param text: Text to answer
+        :param audio: Audio to answer
+        :return: Response
+        """
+        logging.debug(f"Voice message: {text}")
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                timeout = self._get_session_timeout()
+
+                async with session.get(audio, timeout=timeout) as response:
+                    response.raise_for_status()
+                    audio_bytes = await response.read()
+                    audio_data = base64.b64encode(audio_bytes).decode("utf-8")
+
+                llm_message = HumanMessage(
+                    content=[
+                        {
+                            "type": "text",
+                            "text": text,
+                        },
+                        {
+                            "type": "media",
+                            "mime_type": "audio/ogg",
+                            "data": audio_data,
+                        },
+                    ]
+                )
+                self.messages_storage.add_message(llm_message)
+                self.truncate_chat_context()
+                config = self._get_langchain_config(chat_id)
+                response = (
+                    await self.agent.ainvoke(
+                        {"messages": self.system_instructions + self.messages_storage.messages}, config=config
+                    )
+                )["messages"][-1]
+        except (aiohttp.ClientError, Exception) as e:
+            if isinstance(e, aiohttp.ClientError):
+                logging.error(f"Failed to get audio: {audio}")
+            logging.exception(e)
+            response = BaseMessage(content="NO_ANSWER", type="text")
+
+        logging.debug(f"Voice message response: {response}")
+        return response