ag2 0.3.2__py3-none-any.whl

autogen/agentchat/contrib/society_of_mind_agent.py

@@ -0,0 +1,203 @@
+# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+# ruff: noqa: E722
+import copy
+import traceback
+from typing import Callable, Dict, List, Literal, Optional, Tuple, Union
+
+from autogen import Agent, ConversableAgent, GroupChat, GroupChatManager, OpenAIWrapper
+
+
+class SocietyOfMindAgent(ConversableAgent):
+    """(In preview) A single agent that runs a Group Chat as an inner monologue.
+    At the end of the conversation (termination for any reason), the SocietyOfMindAgent
+    applies the response_preparer method on the entire inner monologue message history to
+    extract a final answer for the reply.
+
+    Most arguments are inherited from ConversableAgent. New arguments are:
+        chat_manager (GroupChatManager): the group chat manager that will be running the inner monologue
+        response_preparer (Optional, Callable or String): If response_preparer is a callable function, then
+                it should have the signature:
+                    f( self: SocietyOfMindAgent, messages: List[Dict])
+                where `self` is this SocietyOfMindAgent, and `messages` is a list of inner-monologue messages.
+                The function should return a string representing the final response (extracted or prepared)
+                from that history.
+                If response_preparer is a string, then it should be the LLM prompt used to extract the final
+                message from the inner chat transcript.
+                The default response_preparer depends on if an llm_config is provided. If llm_config is False,
+                then the response_preparer deterministically returns the last message in the inner-monolgue. If
+                llm_config is set to anything else, then a default LLM prompt is used.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        chat_manager: GroupChatManager,
+        response_preparer: Optional[Union[str, Callable]] = None,
+        is_termination_msg: Optional[Callable[[Dict], bool]] = None,
+        max_consecutive_auto_reply: Optional[int] = None,
+        human_input_mode: Literal["ALWAYS", "NEVER", "TERMINATE"] = "TERMINATE",
+        function_map: Optional[Dict[str, Callable]] = None,
+        code_execution_config: Union[Dict, Literal[False]] = False,
+        llm_config: Optional[Union[Dict, Literal[False]]] = False,
+        default_auto_reply: Optional[Union[str, Dict, None]] = "",
+        **kwargs,
+    ):
+        super().__init__(
+            name=name,
+            system_message="",
+            is_termination_msg=is_termination_msg,
+            max_consecutive_auto_reply=max_consecutive_auto_reply,
+            human_input_mode=human_input_mode,
+            function_map=function_map,
+            code_execution_config=code_execution_config,
+            llm_config=llm_config,
+            default_auto_reply=default_auto_reply,
+            **kwargs,
+        )
+
+        self.update_chat_manager(chat_manager)
+
+        # response_preparer default depends on if the llm_config is set, and if a client was created
+        if response_preparer is None:
+            if self.client is not None:
+                response_preparer = "Output a standalone response to the original request, without mentioning any of the intermediate discussion."
+            else:
+
+                def response_preparer(agent, messages):
+                    return messages[-1]["content"].replace("TERMINATE", "").strip()
+
+        # Create the response_preparer callable, if given only a prompt string
+        if isinstance(response_preparer, str):
+            self.response_preparer = lambda agent, messages: agent._llm_response_preparer(response_preparer, messages)
+        else:
+            self.response_preparer = response_preparer
+
+        # NOTE: Async reply functions are not yet supported with this contrib agent
+        self._reply_func_list = []
+        self.register_reply([Agent, None], SocietyOfMindAgent.generate_inner_monologue_reply)
+        self.register_reply([Agent, None], ConversableAgent.generate_code_execution_reply)
+        self.register_reply([Agent, None], ConversableAgent.generate_function_call_reply)
+        self.register_reply([Agent, None], ConversableAgent.check_termination_and_human_reply)
+
+    def _llm_response_preparer(self, prompt, messages):
+        """Default response_preparer when provided with a string prompt, rather than a callable.
+
+        Args:
+            prompt (str): The prompt used to extract the final response from the transcript.
+            messages (list): The messages generated as part of the inner monologue group chat.
+        """
+
+        _messages = [
+            {
+                "role": "system",
+                "content": """Earlier you were asked to fulfill a request. You and your team worked diligently to address that request. Here is a transcript of that conversation:""",
+            }
+        ]
+
+        for message in messages:
+            message = copy.deepcopy(message)
+            message["role"] = "user"
+
+            # Convert tool and function calls to basic messages to avoid an error on the LLM call
+            if "content" not in message:
+                message["content"] = ""
+
+            if "tool_calls" in message:
+                del message["tool_calls"]
+            if "tool_responses" in message:
+                del message["tool_responses"]
+            if "function_call" in message:
+                if message["content"] == "":
+                    try:
+                        message["content"] = (
+                            message["function_call"]["name"] + "(" + message["function_call"]["arguments"] + ")"
+                        )
+                    except KeyError:
+                        pass
+                    del message["function_call"]
+
+            # Add the modified message to the transcript
+            _messages.append(message)
+
+        _messages.append(
+            {
+                "role": "system",
+                "content": prompt,
+            }
+        )
+
+        response = self.client.create(context=None, messages=_messages, cache=self.client_cache, agent=self.name)
+        extracted_response = self.client.extract_text_or_completion_object(response)[0]
+        if not isinstance(extracted_response, str):
+            return str(extracted_response.model_dump(mode="dict"))
+        else:
+            return extracted_response
+
+    @property
+    def chat_manager(self) -> Union[GroupChatManager, None]:
+        """Return the group chat manager."""
+        return self._chat_manager
+
+    def update_chat_manager(self, chat_manager: Union[GroupChatManager, None]):
+        """Update the chat manager.
+
+        Args:
+            chat_manager (GroupChatManager): the group chat manager
+        """
+        self._chat_manager = chat_manager
+
+        # Awkward, but due to object cloning, there's no better way to do this
+        # Read the GroupChat object from the callback
+        self._group_chat = None
+        if self._chat_manager is not None:
+            for item in self._chat_manager._reply_func_list:
+                if isinstance(item["config"], GroupChat):
+                    self._group_chat = item["config"]
+                    break
+
+    def generate_inner_monologue_reply(
+        self,
+        messages: Optional[List[Dict]] = None,
+        sender: Optional[Agent] = None,
+        config: Optional[OpenAIWrapper] = None,
+    ) -> Tuple[bool, Union[str, Dict, None]]:
+        """Generate a reply by running the group chat"""
+        if self.chat_manager is None:
+            return False, None
+        if messages is None:
+            messages = self._oai_messages[sender]
+
+        # We want to clear the inner monolgue, keeping only the exteranl chat for context.
+        # Reset all the counters and histories, then populate agents with necessary context from the external chat
+        self.chat_manager.reset()
+        self.update_chat_manager(self.chat_manager)
+
+        external_history = []
+        if len(messages) > 1:
+            external_history = messages[0 : len(messages) - 1]  # All but the current message
+
+        for agent in self._group_chat.agents:
+            agent.reset()
+            for message in external_history:
+                # Assign each message a name
+                attributed_message = message.copy()
+                if "name" not in attributed_message:
+                    if attributed_message["role"] == "assistant":
+                        attributed_message["name"] = self.name
+                    else:
+                        attributed_message["name"] = sender.name
+
+                self.chat_manager.send(attributed_message, agent, request_reply=False, silent=True)
+
+        try:
+            self.initiate_chat(self.chat_manager, message=messages[-1], clear_history=False)
+        except:
+            traceback.print_exc()
+
+        response_preparer = self.response_preparer
+        return True, response_preparer(self, self._group_chat.messages)

autogen/agentchat/contrib/text_analyzer_agent.py

@@ -0,0 +1,76 @@
+# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+
+from autogen.agentchat.agent import Agent
+from autogen.agentchat.assistant_agent import ConversableAgent
+
+system_message = """You are an expert in text analysis.
+The user will give you TEXT to analyze.
+The user will give you analysis INSTRUCTIONS copied twice, at both the beginning and the end.
+You will follow these INSTRUCTIONS in analyzing the TEXT, then give the results of your expert analysis in the format requested."""
+
+
+class TextAnalyzerAgent(ConversableAgent):
+    """(Experimental) Text Analysis agent, a subclass of ConversableAgent designed to analyze text as instructed."""
+
+    def __init__(
+        self,
+        name="analyzer",
+        system_message: Optional[str] = system_message,
+        human_input_mode: Literal["ALWAYS", "NEVER", "TERMINATE"] = "NEVER",
+        llm_config: Optional[Union[Dict, bool]] = None,
+        **kwargs,
+    ):
+        """
+        Args:
+            name (str): name of the agent.
+            system_message (str): system message for the ChatCompletion inference.
+            human_input_mode (str): This agent should NEVER prompt the human for input.
+            llm_config (dict or False): llm inference configuration.
+                Please refer to [OpenAIWrapper.create](/docs/reference/oai/client#create)
+                for available options.
+                To disable llm-based auto reply, set to False.
+            **kwargs (dict): other kwargs in [ConversableAgent](../conversable_agent#__init__).
+        """
+        super().__init__(
+            name=name,
+            system_message=system_message,
+            human_input_mode=human_input_mode,
+            llm_config=llm_config,
+            **kwargs,
+        )
+        self.register_reply(Agent, TextAnalyzerAgent._analyze_in_reply, position=2)
+
+    def _analyze_in_reply(
+        self,
+        messages: Optional[List[Dict]] = None,
+        sender: Optional[Agent] = None,
+        config: Optional[Any] = None,
+    ) -> Tuple[bool, Union[str, Dict, None]]:
+        """Analyzes the given text as instructed, and returns the analysis as a message.
+        Assumes exactly two messages containing the text to analyze and the analysis instructions.
+        See Teachability.analyze for an example of how to use this method."""
+        if self.llm_config is False:
+            raise ValueError("TextAnalyzerAgent requires self.llm_config to be set in its base class.")
+        if messages is None:
+            messages = self._oai_messages[sender]  # In case of a direct call.
+        assert len(messages) == 2
+
+        # Delegate to the analysis method.
+        return True, self.analyze_text(messages[0]["content"], messages[1]["content"])
+
+    def analyze_text(self, text_to_analyze, analysis_instructions):
+        """Analyzes the given text as instructed, and returns the analysis."""
+        # Assemble the message.
+        text_to_analyze = "# TEXT\n" + text_to_analyze + "\n"
+        analysis_instructions = "# INSTRUCTIONS\n" + analysis_instructions + "\n"
+        msg_text = "\n".join(
+            [analysis_instructions, text_to_analyze, analysis_instructions]
+        )  # Repeat the instructions.
+        # Generate and return the analysis string.
+        return self.generate_oai_reply([{"role": "user", "content": msg_text}], None, None)[1]

autogen/agentchat/contrib/vectordb/base.py

@@ -0,0 +1,243 @@
+# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+from typing import (
+    Any,
+    Callable,
+    List,
+    Mapping,
+    Optional,
+    Protocol,
+    Sequence,
+    Tuple,
+    TypedDict,
+    Union,
+    runtime_checkable,
+)
+
+Metadata = Union[Mapping[str, Any], None]
+Vector = Union[Sequence[float], Sequence[int]]
+ItemID = Union[str, int]  # chromadb doesn't support int ids, VikingDB does
+
+
+class Document(TypedDict):
+    """A Document is a record in the vector database.
+
+    id: ItemID | the unique identifier of the document.
+    content: str | the text content of the chunk.
+    metadata: Metadata, Optional | contains additional information about the document such as source, date, etc.
+    embedding: Vector, Optional | the vector representation of the content.
+    """
+
+    id: ItemID
+    content: str
+    metadata: Optional[Metadata]
+    embedding: Optional[Vector]
+
+
+"""QueryResults is the response from the vector database for a query/queries.
+A query is a list containing one string while queries is a list containing multiple strings.
+The response is a list of query results, each query result is a list of tuples containing the document and the distance.
+"""
+QueryResults = List[List[Tuple[Document, float]]]
+
+
+@runtime_checkable
+class VectorDB(Protocol):
+    """
+    Abstract class for vector database. A vector database is responsible for storing and retrieving documents.
+
+    Attributes:
+        active_collection: Any | The active collection in the vector database. Make get_collection faster. Default is None.
+        type: str | The type of the vector database, chroma, pgvector, etc. Default is "".
+
+    Methods:
+        create_collection: Callable[[str, bool, bool], Any] | Create a collection in the vector database.
+        get_collection: Callable[[str], Any] | Get the collection from the vector database.
+        delete_collection: Callable[[str], Any] | Delete the collection from the vector database.
+        insert_docs: Callable[[List[Document], str, bool], None] | Insert documents into the collection of the vector database.
+        update_docs: Callable[[List[Document], str], None] | Update documents in the collection of the vector database.
+        delete_docs: Callable[[List[ItemID], str], None] | Delete documents from the collection of the vector database.
+        retrieve_docs: Callable[[List[str], str, int, float], QueryResults] | Retrieve documents from the collection of the vector database based on the queries.
+        get_docs_by_ids: Callable[[List[ItemID], str], List[Document]] | Retrieve documents from the collection of the vector database based on the ids.
+    """
+
+    active_collection: Any = None
+    type: str = ""
+    embedding_function: Optional[Callable[[List[str]], List[List[float]]]] = (
+        None  # embeddings = embedding_function(sentences)
+    )
+
+    def create_collection(self, collection_name: str, overwrite: bool = False, get_or_create: bool = True) -> Any:
+        """
+        Create a collection in the vector database.
+        Case 1. if the collection does not exist, create the collection.
+        Case 2. the collection exists, if overwrite is True, it will overwrite the collection.
+        Case 3. the collection exists and overwrite is False, if get_or_create is True, it will get the collection,
+            otherwise it raise a ValueError.
+
+        Args:
+            collection_name: str | The name of the collection.
+            overwrite: bool | Whether to overwrite the collection if it exists. Default is False.
+            get_or_create: bool | Whether to get the collection if it exists. Default is True.
+
+        Returns:
+            Any | The collection object.
+        """
+        ...
+
+    def get_collection(self, collection_name: str = None) -> Any:
+        """
+        Get the collection from the vector database.
+
+        Args:
+            collection_name: str | The name of the collection. Default is None. If None, return the
+                current active collection.
+
+        Returns:
+            Any | The collection object.
+        """
+        ...
+
+    def delete_collection(self, collection_name: str) -> Any:
+        """
+        Delete the collection from the vector database.
+
+        Args:
+            collection_name: str | The name of the collection.
+
+        Returns:
+            Any
+        """
+        ...
+
+    def insert_docs(self, docs: List[Document], collection_name: str = None, upsert: bool = False, **kwargs) -> None:
+        """
+        Insert documents into the collection of the vector database.
+
+        Args:
+            docs: List[Document] | A list of documents. Each document is a TypedDict `Document`.
+            collection_name: str | The name of the collection. Default is None.
+            upsert: bool | Whether to update the document if it exists. Default is False.
+            kwargs: Dict | Additional keyword arguments.
+
+        Returns:
+            None
+        """
+        ...
+
+    def update_docs(self, docs: List[Document], collection_name: str = None, **kwargs) -> None:
+        """
+        Update documents in the collection of the vector database.
+
+        Args:
+            docs: List[Document] | A list of documents.
+            collection_name: str | The name of the collection. Default is None.
+            kwargs: Dict | Additional keyword arguments.
+
+        Returns:
+            None
+        """
+        ...
+
+    def delete_docs(self, ids: List[ItemID], collection_name: str = None, **kwargs) -> None:
+        """
+        Delete documents from the collection of the vector database.
+
+        Args:
+            ids: List[ItemID] | A list of document ids. Each id is a typed `ItemID`.
+            collection_name: str | The name of the collection. Default is None.
+            kwargs: Dict | Additional keyword arguments.
+
+        Returns:
+            None
+        """
+        ...
+
+    def retrieve_docs(
+        self,
+        queries: List[str],
+        collection_name: str = None,
+        n_results: int = 10,
+        distance_threshold: float = -1,
+        **kwargs,
+    ) -> QueryResults:
+        """
+        Retrieve documents from the collection of the vector database based on the queries.
+
+        Args:
+            queries: List[str] | A list of queries. Each query is a string.
+            collection_name: str | The name of the collection. Default is None.
+            n_results: int | The number of relevant documents to return. Default is 10.
+            distance_threshold: float | The threshold for the distance score, only distance smaller than it will be
+                returned. Don't filter with it if < 0. Default is -1.
+            kwargs: Dict | Additional keyword arguments.
+
+        Returns:
+            QueryResults | The query results. Each query result is a list of list of tuples containing the document and
+                the distance.
+        """
+        ...
+
+    def get_docs_by_ids(
+        self, ids: List[ItemID] = None, collection_name: str = None, include=None, **kwargs
+    ) -> List[Document]:
+        """
+        Retrieve documents from the collection of the vector database based on the ids.
+
+        Args:
+            ids: List[ItemID] | A list of document ids. If None, will return all the documents. Default is None.
+            collection_name: str | The name of the collection. Default is None.
+            include: List[str] | The fields to include. Default is None.
+                If None, will include ["metadatas", "documents"], ids will always be included. This may differ
+                depending on the implementation.
+            kwargs: dict | Additional keyword arguments.
+
+        Returns:
+            List[Document] | The results.
+        """
+        ...
+
+
+class VectorDBFactory:
+    """
+    Factory class for creating vector databases.
+    """
+
+    PREDEFINED_VECTOR_DB = ["chroma", "pgvector", "mongodb", "qdrant"]
+
+    @staticmethod
+    def create_vector_db(db_type: str, **kwargs) -> VectorDB:
+        """
+        Create a vector database.
+
+        Args:
+            db_type: str | The type of the vector database.
+            kwargs: Dict | The keyword arguments for initializing the vector database.
+
+        Returns:
+            VectorDB | The vector database.
+        """
+        if db_type.lower() in ["chroma", "chromadb"]:
+            from .chromadb import ChromaVectorDB
+
+            return ChromaVectorDB(**kwargs)
+        if db_type.lower() in ["pgvector", "pgvectordb"]:
+            from .pgvectordb import PGVectorDB
+
+            return PGVectorDB(**kwargs)
+        if db_type.lower() in ["mdb", "mongodb", "atlas"]:
+            from .mongodb import MongoDBAtlasVectorDB
+
+            return MongoDBAtlasVectorDB(**kwargs)
+        if db_type.lower() in ["qdrant", "qdrantdb"]:
+            from .qdrant import QdrantVectorDB
+
+            return QdrantVectorDB(**kwargs)
+        else:
+            raise ValueError(
+                f"Unsupported vector database type: {db_type}. Valid types are {VectorDBFactory.PREDEFINED_VECTOR_DB}."
+            )