From 94dd9d73ab332bdc78ee1e5c57cc08bd18d176b4 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 12 Dec 2024 15:07:31 +0000 Subject: [PATCH 01/70] wip --- autogen/tools/__init__.py | 3 +++ autogen/tools/tool.py | 47 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+) create mode 100644 autogen/tools/__init__.py create mode 100644 autogen/tools/tool.py diff --git a/autogen/tools/__init__.py b/autogen/tools/__init__.py new file mode 100644 index 0000000000..3451ac3111 --- /dev/null +++ b/autogen/tools/__init__.py @@ -0,0 +1,3 @@ +from .tool import Tool + +__all__ = ["Tool"] diff --git a/autogen/tools/tool.py b/autogen/tools/tool.py new file mode 100644 index 0000000000..d73d5166be --- /dev/null +++ b/autogen/tools/tool.py @@ -0,0 +1,47 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +from typing import Any, Callable, Dict +from unittest.mock import MagicMock + +from autogen.agentchat.conversable_agent import ConversableAgent + +try: + from crewai.tools import Tool as CrewAITool +except ImportError: + CrewAITool = MagicMock() + +__all__ = ["Tool"] + + +class Tool: + def __init__(self, name: str, description: str, func: Callable[..., Any], kwargs: Dict[str, Any]): + self._name = name + self._description = description + self._func = func + self._kwargs = kwargs + + def run(self, **kwargs: Any) -> Any: + return self._func(**self._kwargs, **kwargs) + + @classmethod + def from_crewai_tool(self, tool: CrewAITool) -> "Tool": + name = tool.name.replace(" ", "_") + description = tool.description.split("Tool Description: ")[-1] + + def func(args: tool.args_schema) -> Any: + return tool.run(**args.model_dump()) + + return Tool( + name=name, + description=description, + func=func, + kwargs={}, + ) + + def register_for_llm(self, agent: ConversableAgent) -> None: + agent.register_for_llm(name=self._name, description=self._description)(self.run) + + def register_for_execution(self, agent: ConversableAgent) -> None: + agent.register_for_execution(name=self._name, description=self._description)(self.run) From f112397c479576d080332f5cb7ffbd0f7c9c3cfd Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 12 Dec 2024 15:12:30 +0000 Subject: [PATCH 02/70] wip --- autogen/tools/tool.py | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/autogen/tools/tool.py b/autogen/tools/tool.py index d73d5166be..aa6946c8a7 100644 --- a/autogen/tools/tool.py +++ b/autogen/tools/tool.py @@ -16,14 +16,10 @@ class Tool: - def __init__(self, name: str, description: str, func: Callable[..., Any], kwargs: Dict[str, Any]): + def __init__(self, name: str, description: str, func: Callable[..., Any]): self._name = name self._description = description self._func = func - self._kwargs = kwargs - - def run(self, **kwargs: Any) -> Any: - return self._func(**self._kwargs, **kwargs) @classmethod def from_crewai_tool(self, tool: CrewAITool) -> "Tool": @@ -41,7 +37,7 @@ def func(args: tool.args_schema) -> Any: ) def register_for_llm(self, agent: ConversableAgent) -> None: - agent.register_for_llm(name=self._name, description=self._description)(self.run) + agent.register_for_llm(name=self._name, description=self._description)(self._func) def register_for_execution(self, agent: ConversableAgent) -> None: - agent.register_for_execution(name=self._name, description=self._description)(self.run) + agent.register_for_execution(name=self._name, description=self._description)(self._func) From 65b545222064e4beef3f37aca96c8c9a90ada68a Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Thu, 12 Dec 2024 17:20:34 +0100 Subject: [PATCH 03/70] Initial tools tutorial added --- autogen/tools/tool.py | 7 +- notebook/tools_from_crewai_tool.ipynb | 142 ++++++++++++++++++++++++++ 2 files changed, 146 insertions(+), 3 deletions(-) create mode 100644 notebook/tools_from_crewai_tool.ipynb diff --git a/autogen/tools/tool.py b/autogen/tools/tool.py index aa6946c8a7..c23baf362b 100644 --- a/autogen/tools/tool.py +++ b/autogen/tools/tool.py @@ -16,13 +16,14 @@ class Tool: - def __init__(self, name: str, description: str, func: Callable[..., Any]): + def __init__(self, name: str, description: str, func: Callable[..., Any], kwargs: Dict[str, Any]): self._name = name self._description = description self._func = func + self._kwargs = kwargs @classmethod - def from_crewai_tool(self, tool: CrewAITool) -> "Tool": + def from_crewai_tool(cls, tool: CrewAITool) -> "Tool": name = tool.name.replace(" ", "_") description = tool.description.split("Tool Description: ")[-1] @@ -40,4 +41,4 @@ def register_for_llm(self, agent: ConversableAgent) -> None: agent.register_for_llm(name=self._name, description=self._description)(self._func) def register_for_execution(self, agent: ConversableAgent) -> None: - agent.register_for_execution(name=self._name, description=self._description)(self._func) + agent.register_for_execution(name=self._name)(self._func) diff --git a/notebook/tools_from_crewai_tool.ipynb b/notebook/tools_from_crewai_tool.ipynb new file mode 100644 index 0000000000..5de4c5d82f --- /dev/null +++ b/notebook/tools_from_crewai_tool.ipynb @@ -0,0 +1,142 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# ! pip install 'crewai[tools]'" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import tempfile\n", + "from pathlib import Path\n", + "\n", + "from crewai_tools import FileWriterTool\n", + "\n", + "from autogen import AssistantAgent, UserProxyAgent\n", + "from autogen.tools import Tool" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "config_list = [{\"model\": \"gpt-4\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", + "user_proxy = UserProxyAgent(\n", + " name=\"User\",\n", + " human_input_mode=\"NEVER\",\n", + ")\n", + "\n", + "chatbot = AssistantAgent(\n", + " name=\"chatbot\",\n", + " llm_config={\"config_list\": config_list},\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mUser\u001b[0m (to chatbot):\n", + "\n", + "Write 'Easy Migration :)' into tool_result.txt.\n", + "Use /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpplvoeszo dir.\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mchatbot\u001b[0m (to User):\n", + "\n", + "\u001b[32m***** Suggested tool call (call_8BpLgDeuKWZJz6W21U0LmNRq): File_Writer_Tool *****\u001b[0m\n", + "Arguments: \n", + "{\n", + " \"args\": {\n", + " \"filename\": \"tool_result.txt\",\n", + " \"directory\": \"/var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpplvoeszo\",\n", + " \"overwrite\": \"True\",\n", + " \"content\": \"Easy Migration :)\"\n", + " }\n", + "}\n", + "\u001b[32m*********************************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION File_Writer_Tool...\u001b[0m\n", + "Using Tool: File Writer Tool\n", + "\u001b[33mUser\u001b[0m (to chatbot):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_8BpLgDeuKWZJz6W21U0LmNRq) *****\u001b[0m\n", + "Content successfully written to /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpplvoeszo/tool_result.txt\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mchatbot\u001b[0m (to User):\n", + "\n", + "I've successfully written the text 'Easy Migration :)' into the file named 'tool_result.txt' located in the directory '/var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpplvoeszo'. \n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "with tempfile.TemporaryDirectory() as tmpdirname:\n", + " crewai_tool = FileWriterTool()\n", + " ag2_tool = Tool.from_crewai_tool(crewai_tool)\n", + "\n", + " ag2_tool.register_for_execution(user_proxy)\n", + " ag2_tool.register_for_llm(chatbot)\n", + "\n", + " filename = \"tool_result.txt\"\n", + " message = f\"\"\"Write 'Easy Migration :)' into {filename}.\n", + "Use {tmpdirname} dir.\n", + "\"\"\"\n", + " user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)\n", + "\n", + " assert Path(tmpdirname, filename).read_text() == \"Easy Migration :)\"\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 6e34fbf01a0c5d546d2af1e3907b0fedaceb434c Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Thu, 12 Dec 2024 17:30:11 +0100 Subject: [PATCH 04/70] Fix incorrect import from crewai --- autogen/tools/tool.py | 2 +- notebook/tools_from_crewai_tool.ipynb | 47 ++++++++++++++++----------- 2 files changed, 29 insertions(+), 20 deletions(-) diff --git a/autogen/tools/tool.py b/autogen/tools/tool.py index c23baf362b..d223aa0ce4 100644 --- a/autogen/tools/tool.py +++ b/autogen/tools/tool.py @@ -8,7 +8,7 @@ from autogen.agentchat.conversable_agent import ConversableAgent try: - from crewai.tools import Tool as CrewAITool + from crewai.tools import BaseTool as CrewAITool except ImportError: CrewAITool = MagicMock() diff --git a/notebook/tools_from_crewai_tool.ipynb b/notebook/tools_from_crewai_tool.ipynb index 5de4c5d82f..b583a8c0b3 100644 --- a/notebook/tools_from_crewai_tool.ipynb +++ b/notebook/tools_from_crewai_tool.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 10, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -11,9 +11,17 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-12-12 17:28:45,612 - 8269089792 - __init__.py-__init__:18 - WARNING: flaml.automl is not available. Please install flaml[automl] to enable AutoML functionalities.\n" + ] + } + ], "source": [ "import os\n", "import tempfile\n", @@ -27,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -45,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -55,25 +63,19 @@ "\u001b[33mUser\u001b[0m (to chatbot):\n", "\n", "Write 'Easy Migration :)' into tool_result.txt.\n", - "Use /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpplvoeszo dir.\n", - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Use /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpv3px4peq dir.\n", + "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mchatbot\u001b[0m (to User):\n", "\n", - "\u001b[32m***** Suggested tool call (call_8BpLgDeuKWZJz6W21U0LmNRq): File_Writer_Tool *****\u001b[0m\n", + "\u001b[32m***** Suggested tool call (call_or8EnSzoRxayagU27crpydfF): File_Writer_Tool *****\u001b[0m\n", "Arguments: \n", "{\n", " \"args\": {\n", " \"filename\": \"tool_result.txt\",\n", - " \"directory\": \"/var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpplvoeszo\",\n", - " \"overwrite\": \"True\",\n", + " \"directory\": \"/var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpv3px4peq\",\n", + " \"overwrite\": \"yes\",\n", " \"content\": \"Easy Migration :)\"\n", " }\n", "}\n", @@ -85,14 +87,14 @@ "Using Tool: File Writer Tool\n", "\u001b[33mUser\u001b[0m (to chatbot):\n", "\n", - "\u001b[32m***** Response from calling tool (call_8BpLgDeuKWZJz6W21U0LmNRq) *****\u001b[0m\n", - "Content successfully written to /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpplvoeszo/tool_result.txt\n", + "\u001b[32m***** Response from calling tool (call_or8EnSzoRxayagU27crpydfF) *****\u001b[0m\n", + "Content successfully written to /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpv3px4peq/tool_result.txt\n", "\u001b[32m**********************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mchatbot\u001b[0m (to User):\n", "\n", - "I've successfully written the text 'Easy Migration :)' into the file named 'tool_result.txt' located in the directory '/var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpplvoeszo'. \n", + "The content 'Easy Migration :)' has been successfully written to the file /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpv3px4peq/tool_result.txt.\n", "\n", "TERMINATE\n", "\n", @@ -116,6 +118,13 @@ "\n", " assert Path(tmpdirname, filename).read_text() == \"Easy Migration :)\"\n" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 7b22f8bf47b8ba0c7a68aec17ef27b9226674926 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Fri, 13 Dec 2024 08:48:00 +0000 Subject: [PATCH 05/70] refactoring --- autogen/interoperability/__init__.py | 7 +++ autogen/interoperability/crewai/__init__.py | 12 +++++ autogen/interoperability/crewai/crewai.py | 38 ++++++++++++++ autogen/interoperability/interoperability.py | 12 +++++ autogen/tools/tool.py | 30 +++++------ pyproject.toml | 4 ++ setup.py | 1 + test/interoperability/__init__.py | 3 ++ test/interoperability/crewai/__init__.py | 3 ++ test/interoperability/crewai/test_crewai.py | 50 +++++++++++++++++++ .../interoperability/test_interoperability.py | 9 ++++ test/tools/__init__.py | 3 ++ test/tools/test_tool.py | 13 +++++ 13 files changed, 168 insertions(+), 17 deletions(-) create mode 100644 autogen/interoperability/__init__.py create mode 100644 autogen/interoperability/crewai/__init__.py create mode 100644 autogen/interoperability/crewai/crewai.py create mode 100644 autogen/interoperability/interoperability.py create mode 100644 test/interoperability/__init__.py create mode 100644 test/interoperability/crewai/__init__.py create mode 100644 test/interoperability/crewai/test_crewai.py create mode 100644 test/interoperability/test_interoperability.py create mode 100644 test/tools/__init__.py create mode 100644 test/tools/test_tool.py diff --git a/autogen/interoperability/__init__.py b/autogen/interoperability/__init__.py new file mode 100644 index 0000000000..b5dc8c9521 --- /dev/null +++ b/autogen/interoperability/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +from .interoperability import Interoperable + +__all__ = ["Interoperable"] diff --git a/autogen/interoperability/crewai/__init__.py b/autogen/interoperability/crewai/__init__.py new file mode 100644 index 0000000000..63c5268009 --- /dev/null +++ b/autogen/interoperability/crewai/__init__.py @@ -0,0 +1,12 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +try: + import crewai.tools +except ImportError: + raise ImportError("Please install `interop-crewai` extra to use this module:\n\n\tpip install ag2[interop-crewai]") + +from .crewai import CrewAIInteroperability + +__all__ = ["CrewAIInteroperability"] diff --git a/autogen/interoperability/crewai/crewai.py b/autogen/interoperability/crewai/crewai.py new file mode 100644 index 0000000000..490dcbd81f --- /dev/null +++ b/autogen/interoperability/crewai/crewai.py @@ -0,0 +1,38 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +import re +from typing import Any, cast + +from crewai.tools import BaseTool as CrewAITool + +from ...tools import Tool +from ..interoperability import Interoperable + +__all__ = ["CrewAIInteroperability"] + + +def _sanitize_name(s: str) -> str: + return re.sub(r"\W|^(?=\d)", "_", s) + + +class CrewAIInteroperability(Interoperable): + def convert_tool(self, tool: Any) -> Tool: + if not isinstance(tool, CrewAITool): + raise ValueError(f"Expected an instance of `crewai.tools.BaseTool`, got {type(tool)}") + + # needed for type checking + crewai_tool: CrewAITool = tool # type: ignore[no-any-unimported] + + name = _sanitize_name(crewai_tool.name) + description = crewai_tool.description.split("Tool Description: ")[-1] + + def func(args: crewai_tool.args_schema) -> Any: # type: ignore[no-any-unimported] + return crewai_tool.run(**args.model_dump()) + + return Tool( + name=name, + description=description, + func=func, + ) diff --git a/autogen/interoperability/interoperability.py b/autogen/interoperability/interoperability.py new file mode 100644 index 0000000000..436e75bb43 --- /dev/null +++ b/autogen/interoperability/interoperability.py @@ -0,0 +1,12 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +from typing import Any, Protocol, runtime_checkable + +from ..tools import Tool + + +@runtime_checkable +class Interoperable(Protocol): + def convert_tool(self, tool: Any) -> Tool: ... diff --git a/autogen/tools/tool.py b/autogen/tools/tool.py index d223aa0ce4..b42c71179b 100644 --- a/autogen/tools/tool.py +++ b/autogen/tools/tool.py @@ -16,26 +16,22 @@ class Tool: - def __init__(self, name: str, description: str, func: Callable[..., Any], kwargs: Dict[str, Any]): + def __init__(self, name: str, description: str, func: Callable[..., Any]) -> None: self._name = name self._description = description self._func = func - self._kwargs = kwargs - - @classmethod - def from_crewai_tool(cls, tool: CrewAITool) -> "Tool": - name = tool.name.replace(" ", "_") - description = tool.description.split("Tool Description: ")[-1] - - def func(args: tool.args_schema) -> Any: - return tool.run(**args.model_dump()) - - return Tool( - name=name, - description=description, - func=func, - kwargs={}, - ) + + @property + def name(self) -> str: + return self._name + + @property + def description(self) -> str: + return self._description + + @property + def func(self) -> Callable[..., Any]: + return self._func def register_for_llm(self, agent: ConversableAgent) -> None: agent.register_for_llm(name=self._name, description=self._description)(self._func) diff --git a/pyproject.toml b/pyproject.toml index 107c438a7f..66b4bb2b56 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -60,9 +60,13 @@ files = [ "autogen/_pydantic.py", "autogen/function_utils.py", "autogen/io", + "autogen/tools", + "autogen/interoperability", "test/test_pydantic.py", "test/test_function_utils.py", "test/io", + "test/tools", + "test/interoperability", ] exclude = [ "autogen/math_utils\\.py", diff --git a/setup.py b/setup.py index 64a4e7cee0..f6df62332a 100644 --- a/setup.py +++ b/setup.py @@ -121,6 +121,7 @@ "cohere": ["cohere>=5.5.8"], "ollama": ["ollama>=0.3.3", "fix_busted_json>=0.0.18"], "bedrock": ["boto3>=1.34.149"], + "interop-crewai": ["crewai[tools]>=0.86,<1"], } setuptools.setup( diff --git a/test/interoperability/__init__.py b/test/interoperability/__init__.py new file mode 100644 index 0000000000..bcd5401d54 --- /dev/null +++ b/test/interoperability/__init__.py @@ -0,0 +1,3 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/test/interoperability/crewai/__init__.py b/test/interoperability/crewai/__init__.py new file mode 100644 index 0000000000..bcd5401d54 --- /dev/null +++ b/test/interoperability/crewai/__init__.py @@ -0,0 +1,3 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/test/interoperability/crewai/test_crewai.py b/test/interoperability/crewai/test_crewai.py new file mode 100644 index 0000000000..3544c57fa2 --- /dev/null +++ b/test/interoperability/crewai/test_crewai.py @@ -0,0 +1,50 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +from tempfile import TemporaryDirectory +from typing import Protocol + +import pytest +from conftest import reason, skip_openai +from crewai_tools import FileReadTool + +from autogen.interoperability import Interoperable +from autogen.interoperability.crewai import CrewAIInteroperability + + +class TestCrewAIInteroperability: + @pytest.fixture(autouse=True) + def setup(self) -> None: + self.crewai_interop = CrewAIInteroperability() + + def test_type_checks(self) -> None: + # mypy should fail if the type checks are not correct + interop: Interoperable = self.crewai_interop + # runtime check + assert isinstance(interop, Interoperable) + + def test_init(self) -> None: + assert isinstance(self.crewai_interop, Interoperable) + + def test_convert_tool(self) -> None: + with TemporaryDirectory() as tmp_dir: + file_path = f"{tmp_dir}/test.txt" + with open(file_path, "w") as file: + file.write("Hello, World!") + + crewai_tool = FileReadTool() + model_type = crewai_tool.args_schema + + tool = self.crewai_interop.convert_tool(crewai_tool) + + assert tool.name == "Read_a_file_s_content" + assert tool.description == "A tool that can be used to read a file's content." + + args = model_type(file_path=file_path) + + assert tool.func(args=args) == "Hello, World!" + + @pytest.mark.skipif(skip_openai, reason=reason) + def test_with_llm(self) -> None: + assert False, "Test not implemented" diff --git a/test/interoperability/test_interoperability.py b/test/interoperability/test_interoperability.py new file mode 100644 index 0000000000..185cf4b571 --- /dev/null +++ b/test/interoperability/test_interoperability.py @@ -0,0 +1,9 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +from autogen.interoperability import Interoperable + + +def test_interoperable() -> None: + assert Interoperable is not None diff --git a/test/tools/__init__.py b/test/tools/__init__.py new file mode 100644 index 0000000000..bcd5401d54 --- /dev/null +++ b/test/tools/__init__.py @@ -0,0 +1,3 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/test/tools/test_tool.py b/test/tools/test_tool.py new file mode 100644 index 0000000000..bcce27f178 --- /dev/null +++ b/test/tools/test_tool.py @@ -0,0 +1,13 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +from autogen.tools import Tool + + +class TestTool: + def test_init(self) -> None: + tool = Tool(name="Test Tool", description="A test tool", func=lambda: None) + assert tool.name == "Test Tool" + + assert False, "Test not implemented" From 43c7015854776936952a28947cf38cc5fc89b5e0 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Fri, 13 Dec 2024 11:35:06 +0100 Subject: [PATCH 06/70] Upgrade pytest version to >=8.0.0 --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index f6df62332a..df5524ef06 100644 --- a/setup.py +++ b/setup.py @@ -90,7 +90,7 @@ "pre-commit", "pytest-cov>=5", "pytest-asyncio", - "pytest>=6.1.1,<8", + "pytest>=8.0.0,<9", "pandas", ], "blendsearch": ["flaml[blendsearch]"], From 70663d1b816c88559202a491e1ed21714530c103 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Fri, 13 Dec 2024 11:53:10 +0100 Subject: [PATCH 07/70] Add missing tools and crewai tests --- test/interoperability/crewai/test_crewai.py | 49 ++++++++++++++++----- test/tools/test_tool.py | 43 ++++++++++++++++-- 2 files changed, 79 insertions(+), 13 deletions(-) diff --git a/test/interoperability/crewai/test_crewai.py b/test/interoperability/crewai/test_crewai.py index 3544c57fa2..3d26e03d52 100644 --- a/test/interoperability/crewai/test_crewai.py +++ b/test/interoperability/crewai/test_crewai.py @@ -2,6 +2,7 @@ # # SPDX-License-Identifier: Apache-2.0 +import os from tempfile import TemporaryDirectory from typing import Protocol @@ -9,6 +10,7 @@ from conftest import reason, skip_openai from crewai_tools import FileReadTool +from autogen import AssistantAgent, UserProxyAgent from autogen.interoperability import Interoperable from autogen.interoperability.crewai import CrewAIInteroperability @@ -18,6 +20,10 @@ class TestCrewAIInteroperability: def setup(self) -> None: self.crewai_interop = CrewAIInteroperability() + crewai_tool = FileReadTool() + self.model_type = crewai_tool.args_schema + self.tool = self.crewai_interop.convert_tool(crewai_tool) + def test_type_checks(self) -> None: # mypy should fail if the type checks are not correct interop: Interoperable = self.crewai_interop @@ -33,18 +39,41 @@ def test_convert_tool(self) -> None: with open(file_path, "w") as file: file.write("Hello, World!") - crewai_tool = FileReadTool() - model_type = crewai_tool.args_schema - - tool = self.crewai_interop.convert_tool(crewai_tool) + assert self.tool.name == "Read_a_file_s_content" + assert self.tool.description == "A tool that can be used to read a file's content." - assert tool.name == "Read_a_file_s_content" - assert tool.description == "A tool that can be used to read a file's content." + args = self.model_type(file_path=file_path) - args = model_type(file_path=file_path) - - assert tool.func(args=args) == "Hello, World!" + assert self.tool.func(args=args) == "Hello, World!" @pytest.mark.skipif(skip_openai, reason=reason) def test_with_llm(self) -> None: - assert False, "Test not implemented" + config_list = [{"model": "gpt-4", "api_key": os.environ["OPENAI_API_KEY"]}] + user_proxy = UserProxyAgent( + name="User", + human_input_mode="NEVER", + ) + + chatbot = AssistantAgent( + name="chatbot", + llm_config={"config_list": config_list}, + ) + + self.tool.register_for_execution(user_proxy) + self.tool.register_for_llm(chatbot) + + with TemporaryDirectory() as tmp_dir: + file_path = f"{tmp_dir}/test.txt" + with open(file_path, "w") as file: + file.write("Hello, World!") + + user_proxy.initiate_chat( + recipient=chatbot, message=f"Read the content of the file at {file_path}", max_turns=2 + ) + + for message in user_proxy.chat_messages[chatbot]: + if "tool_responses" in message: + assert message["tool_responses"][0]["content"] == "Hello, World!" + return + + assert False, "Tool response not found in chat messages" diff --git a/test/tools/test_tool.py b/test/tools/test_tool.py index bcce27f178..acd77384fd 100644 --- a/test/tools/test_tool.py +++ b/test/tools/test_tool.py @@ -2,12 +2,49 @@ # # SPDX-License-Identifier: Apache-2.0 +import os + +import pytest + +from autogen import AssistantAgent, UserProxyAgent from autogen.tools import Tool class TestTool: + @pytest.fixture(autouse=True) + def setup(self) -> None: + def f(x: str) -> str: + return x + + self.tool = Tool(name="test_tool", description="A test tool", func=f) + def test_init(self) -> None: - tool = Tool(name="Test Tool", description="A test tool", func=lambda: None) - assert tool.name == "Test Tool" + assert self.tool.name == "test_tool" + assert self.tool.description == "A test tool" + + def test_register_for_llm(self) -> None: + config_list = [{"model": "gpt-4", "api_key": os.environ["OPENAI_API_KEY"]}] + + agent = AssistantAgent( + name="agent", + llm_config={"config_list": config_list}, + ) + + self.tool.register_for_llm(agent=agent) + + expected_tools = [ + { + "type": "function", + "function": { + "description": "A test tool", + "name": "test_tool", + "parameters": { + "type": "object", + "properties": {"x": {"type": "string", "description": "x"}}, + "required": ["x"], + }, + }, + } + ] - assert False, "Test not implemented" + assert agent.llm_config["tools"] == expected_tools # type: ignore[index] From 32e0aefa6a30dba9785881550ee78857436fabd7 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Fri, 13 Dec 2024 12:07:48 +0100 Subject: [PATCH 08/70] Add missing test_register_for_execution tools test --- test/tools/test_tool.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/test/tools/test_tool.py b/test/tools/test_tool.py index acd77384fd..b21edebd45 100644 --- a/test/tools/test_tool.py +++ b/test/tools/test_tool.py @@ -14,7 +14,7 @@ class TestTool: @pytest.fixture(autouse=True) def setup(self) -> None: def f(x: str) -> str: - return x + return x + "!" self.tool = Tool(name="test_tool", description="A test tool", func=f) @@ -48,3 +48,12 @@ def test_register_for_llm(self) -> None: ] assert agent.llm_config["tools"] == expected_tools # type: ignore[index] + + def test_register_for_execution(self) -> None: + user_proxy = UserProxyAgent( + name="user", + ) + + self.tool.register_for_execution(user_proxy) + assert user_proxy.can_execute_function("test_tool") + assert user_proxy.function_map["test_tool"]("Hello") == "Hello!" From ce4db6ccced897d95dcd581f1c2eda4c80940513 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Fri, 13 Dec 2024 12:47:10 +0100 Subject: [PATCH 09/70] Add crewai tools integration tutorial --- notebook/tools_crewai_tools_integration.ipynb | 224 ++++++++++++++++++ notebook/tools_from_crewai_tool.ipynb | 151 ------------ 2 files changed, 224 insertions(+), 151 deletions(-) create mode 100644 notebook/tools_crewai_tools_integration.ipynb delete mode 100644 notebook/tools_from_crewai_tool.ipynb diff --git a/notebook/tools_crewai_tools_integration.ipynb b/notebook/tools_crewai_tools_integration.ipynb new file mode 100644 index 0000000000..78b85cbccc --- /dev/null +++ b/notebook/tools_crewai_tools_integration.ipynb @@ -0,0 +1,224 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Integrating CrewAI Tools with the Autogen Framework\n", + "\n", + "In this tutorial, we demonstrate how to integrate [CrewAI Tools](https://github.com/crewAIInc/crewAI-tools/tree/main) into the Autogen framework. This process enables smooth interoperability between the two systems, allowing developers to leverage CrewAI's powerful tools within Autogen's flexible agent-based architecture. By the end of this guide, you will understand how to configure agents, convert CrewAI tools for use in Autogen, and validate the integration with a practical example.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Installation\n", + "Install the required packages for integrating CrewAI tools into the Autogen framework.\n", + "This ensures all dependencies for both frameworks are installed.\n", + "\n", + "```bash\n", + "pip install autogen[interop-crewai]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports\n", + "\n", + "Import necessary modules and tools.\n", + "- `os` is used to access environment variables.\n", + "- `TemporaryDirectory` is used for creating a temporary workspace.\n", + "- `Path` helps in handling file paths.\n", + "- `FileWriterTool` is the CrewAI tool we will integrate.\n", + "- `AssistantAgent` and `UserProxyAgent` are core Autogen classes.\n", + "- `CrewAIInteroperability` facilitates the interoperability between Autogen and CrewAI." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-12-13 12:45:47,330 - 8269089792 - __init__.py-__init__:18 - WARNING: flaml.automl is not available. Please install flaml[automl] to enable AutoML functionalities.\n" + ] + } + ], + "source": [ + "import os\n", + "from pathlib import Path\n", + "from tempfile import TemporaryDirectory\n", + "\n", + "from crewai_tools import FileWriterTool\n", + "\n", + "from autogen import AssistantAgent, UserProxyAgent\n", + "from autogen.interoperability.crewai import CrewAIInteroperability" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Agent Configuration\n", + "\n", + "Configure the agents for the interaction.\n", + "- `config_list` defines the LLM configurations, including the model and API key.\n", + "- `UserProxyAgent` simulates user inputs without requiring actual human interaction (set to `NEVER`).\n", + "- `AssistantAgent` represents the AI agent, configured with the LLM settings." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "config_list = [{\"model\": \"gpt-4\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", + "user_proxy = UserProxyAgent(\n", + " name=\"User\",\n", + " human_input_mode=\"NEVER\",\n", + ")\n", + "\n", + "chatbot = AssistantAgent(\n", + " name=\"chatbot\",\n", + " llm_config={\"config_list\": config_list},\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tool Integration\n", + "\n", + "Initialize and register the CrewAI tool with Autogen.\n", + "- `crewai_tool` is an instance of the `FileWriterTool` from CrewAI.\n", + "- `CrewAIInteroperability` converts the CrewAI tool to make it usable in Autogen.\n", + "- `register_for_execution` and `register_for_llm` allow the tool to work with the UserProxyAgent and AssistantAgent." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "crewai_tool = FileWriterTool()\n", + "crewai_interop = CrewAIInteroperability()\n", + "ag2_tool = crewai_interop.convert_tool(crewai_tool)\n", + "\n", + "ag2_tool.register_for_execution(user_proxy)\n", + "ag2_tool.register_for_llm(chatbot)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Demonstration\n", + "\n", + "Demonstrate the integration by writing to a file using the converted CrewAI tool.\n", + "- A temporary directory is created to simulate a file operation environment.\n", + "- The `message` instructs the chatbot to use the tool to write a specific string into a file.\n", + "- `user_proxy.initiate_chat` starts the interaction, with the chatbot processing the request and using the tool.\n", + "- Finally, the output file is verified to ensure the integration works correctly." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mUser\u001b[0m (to chatbot):\n", + "\n", + "Write 'Easy Migration :)' into tool_result.txt.\n", + "Use /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpwg6ibnmg dir.\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mchatbot\u001b[0m (to User):\n", + "\n", + "\u001b[32m***** Suggested tool call (call_en1Jhr0uYnWnMdQCaZz0WxQq): File_Writer_Tool *****\u001b[0m\n", + "Arguments: \n", + "{\n", + " \"args\": {\n", + " \"filename\": \"tool_result.txt\",\n", + " \"directory\": \"/var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpwg6ibnmg\",\n", + " \"overwrite\": \"yes\",\n", + " \"content\": \"Easy Migration :)\"\n", + " }\n", + "}\n", + "\u001b[32m*********************************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION File_Writer_Tool...\u001b[0m\n", + "Using Tool: File Writer Tool\n", + "\u001b[33mUser\u001b[0m (to chatbot):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_en1Jhr0uYnWnMdQCaZz0WxQq) *****\u001b[0m\n", + "Content successfully written to /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpwg6ibnmg/tool_result.txt\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mchatbot\u001b[0m (to User):\n", + "\n", + "The text \"Easy Migration :)\" has been successfully written into the file \"tool_result.txt\" in the directory \"/var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpwg6ibnmg\".\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "with TemporaryDirectory() as tmpdirname:\n", + " filename = \"tool_result.txt\"\n", + " message = f\"\"\"Write 'Easy Migration :)' into {filename}.\n", + "Use {tmpdirname} dir.\n", + "\"\"\"\n", + " user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)\n", + "\n", + " assert Path(tmpdirname, filename).read_text() == \"Easy Migration :)\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebook/tools_from_crewai_tool.ipynb b/notebook/tools_from_crewai_tool.ipynb deleted file mode 100644 index b583a8c0b3..0000000000 --- a/notebook/tools_from_crewai_tool.ipynb +++ /dev/null @@ -1,151 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# ! pip install 'crewai[tools]'" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-12-12 17:28:45,612 - 8269089792 - __init__.py-__init__:18 - WARNING: flaml.automl is not available. Please install flaml[automl] to enable AutoML functionalities.\n" - ] - } - ], - "source": [ - "import os\n", - "import tempfile\n", - "from pathlib import Path\n", - "\n", - "from crewai_tools import FileWriterTool\n", - "\n", - "from autogen import AssistantAgent, UserProxyAgent\n", - "from autogen.tools import Tool" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "config_list = [{\"model\": \"gpt-4\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", - "user_proxy = UserProxyAgent(\n", - " name=\"User\",\n", - " human_input_mode=\"NEVER\",\n", - ")\n", - "\n", - "chatbot = AssistantAgent(\n", - " name=\"chatbot\",\n", - " llm_config={\"config_list\": config_list},\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[33mUser\u001b[0m (to chatbot):\n", - "\n", - "Write 'Easy Migration :)' into tool_result.txt.\n", - "Use /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpv3px4peq dir.\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mchatbot\u001b[0m (to User):\n", - "\n", - "\u001b[32m***** Suggested tool call (call_or8EnSzoRxayagU27crpydfF): File_Writer_Tool *****\u001b[0m\n", - "Arguments: \n", - "{\n", - " \"args\": {\n", - " \"filename\": \"tool_result.txt\",\n", - " \"directory\": \"/var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpv3px4peq\",\n", - " \"overwrite\": \"yes\",\n", - " \"content\": \"Easy Migration :)\"\n", - " }\n", - "}\n", - "\u001b[32m*********************************************************************************\u001b[0m\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[35m\n", - ">>>>>>>> EXECUTING FUNCTION File_Writer_Tool...\u001b[0m\n", - "Using Tool: File Writer Tool\n", - "\u001b[33mUser\u001b[0m (to chatbot):\n", - "\n", - "\u001b[32m***** Response from calling tool (call_or8EnSzoRxayagU27crpydfF) *****\u001b[0m\n", - "Content successfully written to /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpv3px4peq/tool_result.txt\n", - "\u001b[32m**********************************************************************\u001b[0m\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mchatbot\u001b[0m (to User):\n", - "\n", - "The content 'Easy Migration :)' has been successfully written to the file /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpv3px4peq/tool_result.txt.\n", - "\n", - "TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n" - ] - } - ], - "source": [ - "with tempfile.TemporaryDirectory() as tmpdirname:\n", - " crewai_tool = FileWriterTool()\n", - " ag2_tool = Tool.from_crewai_tool(crewai_tool)\n", - "\n", - " ag2_tool.register_for_execution(user_proxy)\n", - " ag2_tool.register_for_llm(chatbot)\n", - "\n", - " filename = \"tool_result.txt\"\n", - " message = f\"\"\"Write 'Easy Migration :)' into {filename}.\n", - "Use {tmpdirname} dir.\n", - "\"\"\"\n", - " user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)\n", - "\n", - " assert Path(tmpdirname, filename).read_text() == \"Easy Migration :)\"\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From c38a6d21a09e3f15f0197d64727c88aeb2f02f61 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Fri, 13 Dec 2024 13:01:51 +0100 Subject: [PATCH 10/70] Add interop-crewai dependency to setup_ag2 and setup_autogen --- setup_ag2.py | 1 + setup_autogen.py | 1 + 2 files changed, 2 insertions(+) diff --git a/setup_ag2.py b/setup_ag2.py index 1a659ee875..f40dd99e27 100644 --- a/setup_ag2.py +++ b/setup_ag2.py @@ -54,6 +54,7 @@ "cohere": ["pyautogen[cohere]==" + __version__], "ollama": ["pyautogen[ollama]==" + __version__], "bedrock": ["pyautogen[bedrock]==" + __version__], + "interop-crewai": ["pyautogen[interop-crewai]==" + __version__], }, url="https://github.com/ag2ai/ag2", author="Chi Wang & Qingyun Wu", diff --git a/setup_autogen.py b/setup_autogen.py index 1e54c94369..68bf0050b3 100644 --- a/setup_autogen.py +++ b/setup_autogen.py @@ -54,6 +54,7 @@ "cohere": ["pyautogen[cohere]==" + __version__], "ollama": ["pyautogen[ollama]==" + __version__], "bedrock": ["pyautogen[bedrock]==" + __version__], + "interop-crewai": ["pyautogen[interop-crewai]==" + __version__], }, url="https://github.com/ag2ai/ag2", author="Chi Wang & Qingyun Wu", From a5482b81c0041d6d608c512267478bb07d5ce908 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Fri, 13 Dec 2024 13:10:34 +0100 Subject: [PATCH 11/70] Add interop-crewai dependency in the build.yml --- .github/workflows/build.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 0bd7ee3d57..02011c464c 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -71,7 +71,7 @@ jobs: - name: Install packages and dependencies run: | python -m pip install --upgrade pip wheel - pip install -e .[cosmosdb] + pip install -e .[cosmosdb,interop-crewai] python -c "import autogen" pip install pytest-cov>=5 mock - name: Install optional dependencies for code executors From a2aeca0823421a255437bb0299dabec1158219d5 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Fri, 13 Dec 2024 13:49:57 +0100 Subject: [PATCH 12/70] wip Signed-off-by: Davor Runje --- MAINTAINERS.md | 2 +- .../graph_rag/falkor_graph_query_engine.py | 36 +- .../graph_rag/neo4j_graph_query_engine.py | 2 +- notebook/agentchat_graph_rag_falkordb.ipynb | 60 ++- notebook/agentchat_graph_rag_neo4j.ipynb | 414 +++++++----------- setup.py | 10 +- setup_ag2.py | 1 + setup_autogen.py | 1 + .../graph_rag/BUZZ_Employee_Handbook.docx | Bin 0 -> 13226 bytes ...mployment-Opportunity-Policy-Detailed.docx | Bin 0 -> 12435 bytes .../contrib/graph_rag/test_neo4j_graph_rag.py | 40 +- 11 files changed, 260 insertions(+), 306 deletions(-) create mode 100644 test/agentchat/contrib/graph_rag/BUZZ_Employee_Handbook.docx create mode 100644 test/agentchat/contrib/graph_rag/BUZZ_Equal-Employment-Opportunity-Policy-Detailed.docx diff --git a/MAINTAINERS.md b/MAINTAINERS.md index cbcceaa60a..e3b03a56da 100644 --- a/MAINTAINERS.md +++ b/MAINTAINERS.md @@ -23,7 +23,7 @@ | Eric Moore | [emooreatx](https://github.com/emooreatx) | IBM | all| | Evan David | [evandavid1](https://github.com/evandavid1) | - | all | | Tvrtko Sternak | [sternakt](https://github.com/sternakt) | airt.ai | structured output | - +| Jiacheng Shang | [Eric-Shang](https://github.com/Eric-Shang) | Toast | RAG | **Pending Maintainers list (Marked with \*, Waiting for explicit approval from the maintainers)** | Name | GitHub Handle | Organization | Features | diff --git a/autogen/agentchat/contrib/graph_rag/falkor_graph_query_engine.py b/autogen/agentchat/contrib/graph_rag/falkor_graph_query_engine.py index ef984279d9..d374c9ed46 100644 --- a/autogen/agentchat/contrib/graph_rag/falkor_graph_query_engine.py +++ b/autogen/agentchat/contrib/graph_rag/falkor_graph_query_engine.py @@ -49,6 +49,7 @@ def __init__( If None, FalkorDB will auto generate an ontology from the input docs. """ self.name = name + self.ontology_table_name = name + "_ontology" self.host = host self.port = port self.username = username @@ -65,7 +66,7 @@ def connect_db(self): """ if self.name in self.falkordb.list_graphs(): try: - self.ontology = self._load_ontology_from_db(self.name) + self.ontology = self._load_ontology_from_db() except Exception: warnings.warn("Graph Ontology is not loaded.") @@ -103,6 +104,8 @@ def init_db(self, input_doc: List[Document]): sources=sources, model=self.model, ) + # Save Ontology to graph for future access. + self._save_ontology_to_db(self.ontology) self.knowledge_graph = KnowledgeGraph( name=self.name, @@ -118,9 +121,6 @@ def init_db(self, input_doc: List[Document]): # Establishing a chat session will maintain the history self._chat_session = self.knowledge_graph.chat_session() - - # Save Ontology to graph for future access. - self._save_ontology_to_db(self.name, self.ontology) else: raise ValueError("No input documents could be loaded.") @@ -149,17 +149,31 @@ def query(self, question: str, n_results: int = 1, **kwargs) -> GraphStoreQueryR return GraphStoreQueryResult(answer=response["response"], results=[]) - def __get_ontology_storage_graph(self, graph_name: str) -> Graph: - ontology_table_name = graph_name + "_ontology" - return self.falkordb.select_graph(ontology_table_name) + def delete(self) -> bool: + """ + Delete graph and its data from database. + """ + all_graphs = self.falkordb.list_graphs() + if self.name in all_graphs: + self.falkordb.select_graph(self.name).delete() + if self.ontology_table_name in all_graphs: + self.falkordb.select_graph(self.ontology_table_name).delete() + return True + + def __get_ontology_storage_graph(self) -> Graph: + return self.falkordb.select_graph(self.ontology_table_name) - def _save_ontology_to_db(self, graph_name: str, ontology: Ontology): + def _save_ontology_to_db(self, ontology: Ontology): """ Save graph ontology to a separate table with {graph_name}_ontology """ - graph = self.__get_ontology_storage_graph(graph_name) + if self.ontology_table_name in self.falkordb.list_graphs(): + raise ValueError("Knowledge graph {} is already created.".format(self.name)) + graph = self.__get_ontology_storage_graph() ontology.save_to_graph(graph) - def _load_ontology_from_db(self, graph_name: str) -> Ontology: - graph = self.__get_ontology_storage_graph(graph_name) + def _load_ontology_from_db(self) -> Ontology: + if self.ontology_table_name not in self.falkordb.list_graphs(): + raise ValueError("Knowledge graph {} has not been created.".format(self.name)) + graph = self.__get_ontology_storage_graph() return Ontology.from_graph(graph) diff --git a/autogen/agentchat/contrib/graph_rag/neo4j_graph_query_engine.py b/autogen/agentchat/contrib/graph_rag/neo4j_graph_query_engine.py index 9146abffdc..5b9753c10a 100644 --- a/autogen/agentchat/contrib/graph_rag/neo4j_graph_query_engine.py +++ b/autogen/agentchat/contrib/graph_rag/neo4j_graph_query_engine.py @@ -38,7 +38,7 @@ def __init__( database: str = "neo4j", username: str = "neo4j", password: str = "neo4j", - llm: LLM = OpenAI(model="gpt-3.5-turbo", temperature=0.0), + llm: LLM = OpenAI(model="gpt-4o", temperature=0.0), embedding: BaseEmbedding = OpenAIEmbedding(model_name="text-embedding-3-small"), entities: Optional[TypeAlias] = None, relations: Optional[TypeAlias] = None, diff --git a/notebook/agentchat_graph_rag_falkordb.ipynb b/notebook/agentchat_graph_rag_falkordb.ipynb index 4697da6a9a..9db9f959a5 100644 --- a/notebook/agentchat_graph_rag_falkordb.ipynb +++ b/notebook/agentchat_graph_rag_falkordb.ipynb @@ -48,18 +48,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - } - ], + "outputs": [], "source": [ "import os\n", "\n", @@ -108,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -127,12 +118,12 @@ "--------------------------------------------------------------------------------\n", "\u001b[33muser_proxy\u001b[0m (to matrix_agent):\n", "\n", - "Who else acted in The Matrix?\n", + "Any additional actors?\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mmatrix_agent\u001b[0m (to user_proxy):\n", "\n", - "Based on the provided information, there is no additional data about other actors who acted in 'The Matrix' outside of Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving.\n", + "I'm sorry, but I don't have information about any additional actors from 'The Matrix' beyond Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving.\n", "\n", "--------------------------------------------------------------------------------\n" ] @@ -140,10 +131,10 @@ { "data": { "text/plain": [ - "ChatResult(chat_id=None, chat_history=[{'content': \"Name a few actors who've played in 'The Matrix'\", 'role': 'assistant', 'name': 'user_proxy'}, {'content': \"Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving are a few actors who've played in 'The Matrix'.\", 'role': 'user', 'name': 'matrix_agent'}, {'content': 'Who else acted in The Matrix?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': \"Based on the provided information, there is no additional data about other actors who acted in 'The Matrix' outside of Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving.\", 'role': 'user', 'name': 'matrix_agent'}], summary=\"Based on the provided information, there is no additional data about other actors who acted in 'The Matrix' outside of Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving.\", cost={'usage_including_cached_inference': {'total_cost': 0}, 'usage_excluding_cached_inference': {'total_cost': 0}}, human_input=['Who else acted in The Matrix?', 'exit'])" + "ChatResult(chat_id=None, chat_history=[{'content': \"Name a few actors who've played in 'The Matrix'\", 'role': 'assistant', 'name': 'user_proxy'}, {'content': \"Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving are a few actors who've played in 'The Matrix'.\", 'role': 'user', 'name': 'matrix_agent'}, {'content': 'Any additional actors?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': \"I'm sorry, but I don't have information about any additional actors from 'The Matrix' beyond Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving.\", 'role': 'user', 'name': 'matrix_agent'}], summary=\"I'm sorry, but I don't have information about any additional actors from 'The Matrix' beyond Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving.\", cost={'usage_including_cached_inference': {'total_cost': 0}, 'usage_excluding_cached_inference': {'total_cost': 0}}, human_input=['Any additional actors?', 'exit'])" ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -161,7 +152,7 @@ "# Create FalkorGraphQueryEngine\n", "query_engine = FalkorGraphQueryEngine(\n", " name=\"The_Matrix_Auto\",\n", - " host=\"172.18.0.3\", # Change\n", + " host=\"172.17.0.4\", # Change\n", " port=6379, # if needed\n", ")\n", "\n", @@ -197,7 +188,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -219,7 +210,7 @@ "\n", "query_engine = FalkorGraphQueryEngine(\n", " name=\"IMDB\",\n", - " host=\"172.18.0.3\", # Change\n", + " host=\"172.17.0.4\", # Change\n", " port=6379, # if needed\n", " ontology=movie_ontology,\n", ")\n", @@ -240,7 +231,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -254,7 +245,7 @@ "--------------------------------------------------------------------------------\n", "\u001b[33mmatrix_agent\u001b[0m (to user_proxy):\n", "\n", - "Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving are some of the actors who have played in \"The Matrix\".\n", + "Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving have played in 'The Matrix'.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33muser_proxy\u001b[0m (to matrix_agent):\n", @@ -264,7 +255,7 @@ "--------------------------------------------------------------------------------\n", "\u001b[33mmatrix_agent\u001b[0m (to user_proxy):\n", "\n", - "No other actors are listed as having acted in \"The Matrix\" beyond Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving.\n", + "Based on the provided information, Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving are the actors listed for 'The Matrix'. No additional actors are mentioned in the data.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33muser_proxy\u001b[0m (to matrix_agent):\n", @@ -282,10 +273,10 @@ { "data": { "text/plain": [ - "ChatResult(chat_id=None, chat_history=[{'content': \"Name a few actors who've played in 'The Matrix'\", 'role': 'assistant', 'name': 'user_proxy'}, {'content': 'Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving are some of the actors who have played in \"The Matrix\".', 'role': 'user', 'name': 'matrix_agent'}, {'content': 'Who else acted in The Matrix?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': 'No other actors are listed as having acted in \"The Matrix\" beyond Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving.', 'role': 'user', 'name': 'matrix_agent'}, {'content': 'Where was The Matrix filmed?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': 'I am sorry, I could not find the answer to your question', 'role': 'user', 'name': 'matrix_agent'}], summary='I am sorry, I could not find the answer to your question', cost={'usage_including_cached_inference': {'total_cost': 0}, 'usage_excluding_cached_inference': {'total_cost': 0}}, human_input=['Who else acted in The Matrix?', 'Where was The Matrix filmed?', 'exit'])" + "ChatResult(chat_id=None, chat_history=[{'content': \"Name a few actors who've played in 'The Matrix'\", 'role': 'assistant', 'name': 'user_proxy'}, {'content': \"Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving have played in 'The Matrix'.\", 'role': 'user', 'name': 'matrix_agent'}, {'content': 'Who else acted in The Matrix?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': \"Based on the provided information, Keanu Reeves, Laurence Fishburne, Carrie-Anne Moss, and Hugo Weaving are the actors listed for 'The Matrix'. No additional actors are mentioned in the data.\", 'role': 'user', 'name': 'matrix_agent'}, {'content': 'Where was The Matrix filmed?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': 'I am sorry, I could not find the answer to your question', 'role': 'user', 'name': 'matrix_agent'}], summary='I am sorry, I could not find the answer to your question', cost={'usage_including_cached_inference': {'total_cost': 0}, 'usage_excluding_cached_inference': {'total_cost': 0}}, human_input=['Who else acted in The Matrix?', 'Where was The Matrix filmed?', 'exit'])" ] }, - "execution_count": 4, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -326,6 +317,27 @@ "- There is inbuilt awareness of answers it has provided previously\n", "- It can't answer any questions outside of the actors and movies entities as we didn't include anything else in the ontology" ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Remove graph from database:\n", + "query_engine.delete()" + ] } ], "metadata": { diff --git a/notebook/agentchat_graph_rag_neo4j.ipynb b/notebook/agentchat_graph_rag_neo4j.ipynb index e7fb280043..d68ba8971d 100644 --- a/notebook/agentchat_graph_rag_neo4j.ipynb +++ b/notebook/agentchat_graph_rag_neo4j.ipynb @@ -4,17 +4,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Using Neo4j LlamaIndex query engine with AG2 agents for GraphRAG Question & Answering\n", + "# Using Neo4j's graph database with AG2 agents for Question & Answering\n", + "\n", + "AG2 provides GraphRAG integration through agent capabilities. This is an example utilising the integration of Neo4j's property graph database with LlamaIndex's graph query engine.\n", "\n", - " AG2 provides GraphRAG integration using agent capabilities. This is an example to integrate Neo4j property graph and LlamaIndex graph query engine.\n", "\n", "````{=mdx}\n", ":::info Requirements\n", - "llama-index dependencies, which is required to use Neo4j prpoerty graph\n", + "To install the LlamaIndex, Neo4j, and document processing dependencies, install with the 'neo4j' extra:\n", "\n", "```bash\n", - "pip install llama-index==0.11.8 llama-index-graph-stores-neo4j==0.3.0 llama-index-core==0.11.8\n", - "```\n" + "pip install ag2[neo4j]\n", + "```" ] }, { @@ -23,7 +24,7 @@ "source": [ "## Set Configuration and OpenAI API Key\n", "\n", - "By default, in order to use FalkorDB you need to have an OpenAI key in your environment variable `OPENAI_API_KEY`.\n", + "By default, in order to use LlamaIndex with Neo4j you need to have an OpenAI key in your environment variable `OPENAI_API_KEY`.\n", "\n", "You can utilise an OAI_CONFIG_LIST file and extract the OpenAI API key and put it in the environment, as will be shown in the following cell.\n", "\n", @@ -40,22 +41,13 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - } - ], + "outputs": [], "source": [ "import os\n", "\n", "import autogen\n", "\n", - "config_list = autogen.config_list_from_json(env_or_file=\"OAI_CONFIG_LIST\", file_location=\"../\")\n", + "config_list = autogen.config_list_from_json(env_or_file=\"OAI_CONFIG_LIST\", file_location=\".\")\n", "\n", "# Put the OpenAI API key into the environment\n", "os.environ[\"OPENAI_API_KEY\"] = config_list[0][\"api_key\"]" @@ -81,7 +73,7 @@ "\n", "> **Important** \n", "> - **Default Models**:\n", - "> - **Question Answering**: OpenAI's `GPT-3.5-turbo` with `temperature=0.0`.\n", + "> - **Question Answering**: OpenAI's `GPT-4o` with `temperature=0.0`.\n", "> - **Embedding**: OpenAI's `text-embedding-3-small`.\n", "> \n", "> - **Customization**:\n", @@ -101,11 +93,23 @@ "\n", "**Note:** You need to have a Neo4j database running. If you are running one in a Docker container, please ensure your Docker network is setup to allow access to it. \n", "\n", - "In this example, the Neo4j endpoint is set to host=\"bolt://172.17.0.4\" and port=7687, please adjust accordingly. For how to spin up a Neo4j with Docker, you can refer to [this](https://docs.llamaindex.ai/en/stable/examples/property_graph/property_graph_neo4j/#:~:text=stores%2Dneo4j-,Docker%20Setup,%C2%B6,-To%20launch%20Neo4j)\n", + "In this example, the Neo4j endpoint is set to host=\"bolt://172.17.0.3\" and port=7687, please adjust accordingly. For how to spin up a Neo4j with Docker, you can refer to [this](https://docs.llamaindex.ai/en/stable/examples/property_graph/property_graph_neo4j/#:~:text=stores%2Dneo4j-,Docker%20Setup,%C2%B6,-To%20launch%20Neo4j)\n", "\n", - "Below, we have some sample data from Paul Grahma's [essay](https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt).\n", + "We initialise the database with a Word document, creating the Property graph in Neo4j." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# IMPORTS\n", + "from llama_index.embeddings.openai import OpenAIEmbedding\n", + "from llama_index.llms.openai import OpenAI\n", "\n", - "We then initialise the database with that text document, creating the graph in Neo4j." + "from autogen import ConversableAgent, UserProxyAgent\n", + "from autogen.agentchat.contrib.graph_rag.neo4j_graph_query_engine import Neo4jGraphQueryEngine" ] }, { @@ -114,278 +118,188 @@ "source": [ "### A Simple Example\n", "\n", - "In this example, the graph schema is auto-generated. This allows you to load data without specifying the specific types of entities and relationships that will make up the database (however, this may not be optimal and not cost efficient). \n", - "First, we create a Neo4j property graph (knowledge graph) with Paul Grahma's essay." + "In this example, the graph schema is auto-generated. This allows you to load data without specifying the specific types of entities and relationships that will make up the database. However, it will only use some default simple relationships including \"WORKED_ON\", \"MENTIONS\", \"LOCATED_IN\" \n", + "\n", + "LlamaIndex supports a lot of extensions including docx, text, pdf, csv, etc. Find more details in Neo4jGraphQueryEngine. You may need to install dependencies for each extension. In this example, we need `pip install docx2txt`\n", + "\n", + "We start by creating a Neo4j property graph (knowledge graph) with a sample employee handbook of a finctional company called BUZZ" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# load documents\n", "from autogen.agentchat.contrib.graph_rag.document import Document, DocumentType\n", "\n", - "input_path = \"../test/agentchat/contrib/graph_rag/paul_graham_essay.txt\"\n", + "input_path = \"../test/agentchat/contrib/graph_rag/BUZZ_Employee_Handbook.docx\"\n", "input_documents = [Document(doctype=DocumentType.TEXT, path_or_url=input_path)]" ] }, { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Received notification from DBMS server: {severity: WARNING} {code: Neo.ClientNotification.Statement.FeatureDeprecationWarning} {category: DEPRECATION} {title: This feature is deprecated and will be removed in future versions.} {description: The procedure has a deprecated field. ('config' used by 'apoc.meta.graphSample' is deprecated.)} {position: line: 1, column: 1, offset: 0} for query: \"CALL apoc.meta.graphSample() YIELD nodes, relationships RETURN nodes, [rel in relationships | {name:apoc.any.property(rel, 'type'), count: apoc.any.property(rel, 'count')}] AS relationships\"\n", - "Parsing nodes: 100%|██████████| 1/1 [00:00<00:00, 27.73it/s]\n", - "Extracting paths from text with schema: 100%|██████████| 22/22 [00:58<00:00, 2.66s/it]\n", - "Generating embeddings: 100%|██████████| 1/1 [00:01<00:00, 1.52s/it]\n", - "Generating embeddings: 100%|██████████| 2/2 [00:04<00:00, 2.15s/it]\n", - "Received notification from DBMS server: {severity: WARNING} {code: Neo.ClientNotification.Statement.FeatureDeprecationWarning} {category: DEPRECATION} {title: This feature is deprecated and will be removed in future versions.} {description: CALL subquery without a variable scope clause is now deprecated. Use CALL (e, row) { ... }} {position: line: 10, column: 21, offset: 397} for query: \"\\n UNWIND $data AS row\\n MERGE (e:__Node__ {id: row.id})\\n SET e += apoc.map.clean(row.properties, [], [])\\n SET e.name = row.name, e:`__Entity__`\\n WITH e, row\\n CALL apoc.create.addLabels(e, [row.label])\\n YIELD node\\n WITH e, row\\n CALL {\\n WITH e, row\\n WITH e, row\\n WHERE row.embedding IS NOT NULL\\n CALL db.create.setNodeVectorProperty(e, 'embedding', row.embedding)\\n RETURN count(*) AS count\\n }\\n WITH e, row WHERE row.properties.triplet_source_id IS NOT NULL\\n MERGE (c:__Node__ {id: row.properties.triplet_source_id})\\n MERGE (e)<-[:MENTIONS]-(c)\\n \"\n", - "Received notification from DBMS server: {severity: WARNING} {code: Neo.ClientNotification.Statement.FeatureDeprecationWarning} {category: DEPRECATION} {title: This feature is deprecated and will be removed in future versions.} {description: The procedure has a deprecated field. ('config' used by 'apoc.meta.graphSample' is deprecated.)} {position: line: 1, column: 1, offset: 0} for query: \"CALL apoc.meta.graphSample() YIELD nodes, relationships RETURN nodes, [rel in relationships | {name:apoc.any.property(rel, 'type'), count: apoc.any.property(rel, 'count')}] AS relationships\"\n" - ] + "attachments": { + "neo4j_property_graph_1.png": { + "image/png": "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" } - ], + }, + "cell_type": "markdown", + "metadata": {}, "source": [ - "# Auto generate graph schema from unstructured data\n", - "from llama_index.embeddings.openai import OpenAIEmbedding\n", - "from llama_index.llms.openai import OpenAI\n", + "An example property graph:\n", "\n", - "from autogen import ConversableAgent, UserProxyAgent\n", - "from autogen.agentchat.contrib.graph_rag.neo4j_graph_query_engine import Neo4jGraphQueryEngine\n", - "\n", - "# Create FalkorGraphQueryEngine\n", - "query_engine = Neo4jGraphQueryEngine(\n", - " username=\"neo4j\", # Change if you reset username\n", - " password=\"password\", # Change if you reset password\n", - " host=\"bolt://172.17.0.3\", # Change\n", - " port=7687, # if needed\n", - " llm=OpenAI(model=\"gpt-3.5-turbo\", temperature=0.0), # Default, no need to specify\n", - " embedding=OpenAIEmbedding(model_name=\"text-embedding-3-small\"), # except you want to use a different model\n", - " database=\"neo4j\", # Change if you want to store the graphh in your custom database\n", - ")\n", - "\n", - "# Ingest data and initialize the database\n", - "query_engine.init_db(input_doc=input_documents)" + "![neo4j_property_graph_1.png](attachment:neo4j_property_graph_1.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Add capability to a ConversableAgent and query them" + "### Schema\n", + "Define our custom entities, relations and schema" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[33muser_proxy\u001b[0m (to paul_graham_agent):\n", - "\n", - "What happened at Interleaf and Viaweb?\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mpaul_graham_agent\u001b[0m (to user_proxy):\n", - "\n", - "Interleaf was a company that had smart people and built impressive technology but got crushed by Moore's Law in the 1990s. On the other hand, Viaweb was a company founded by the author and his partner to put art galleries online. However, they realized that art galleries didn't want to be online, and they pivoted to building online stores instead. They developed software to generate web stores and transitioned to creating web apps that allowed users to control the software through a browser, leading to the establishment of Viaweb as a pioneering web application company.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33muser_proxy\u001b[0m (to paul_graham_agent):\n", - "\n", - "What did Paul Graham do at Interleaf\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mpaul_graham_agent\u001b[0m (to user_proxy):\n", - "\n", - "Paul Graham did freelance Lisp hacking work at Interleaf.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33muser_proxy\u001b[0m (to paul_graham_agent):\n", - "\n", - "Did he work well?\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mpaul_graham_agent\u001b[0m (to user_proxy):\n", - "\n", - "He demonstrated a strong work ethic and a willingness to explore various projects and opportunities, which ultimately led to successful endeavors such as writing essays, developing spam filters, investing in startups, and founding an investment firm.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33muser_proxy\u001b[0m (to paul_graham_agent):\n", - "\n", - "Did he work well at Interleaf?\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mpaul_graham_agent\u001b[0m (to user_proxy):\n", - "\n", - "He was nervous about money at Interleaf as he sensed the company was on the way down. He decided to write another book on Lisp to secure his financial situation. Ultimately, he chose to drop out of RISD and pursue other opportunities.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33muser_proxy\u001b[0m (to paul_graham_agent):\n", - "\n", - "Did Paul Graham like eating burger?\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mpaul_graham_agent\u001b[0m (to user_proxy):\n", - "\n", - "There is no information provided in the context about Paul Graham's preference for eating burgers.\n", - "\n", - "--------------------------------------------------------------------------------\n" - ] - }, - { - "data": { - "text/plain": [ - "ChatResult(chat_id=None, chat_history=[{'content': 'What happened at Interleaf and Viaweb?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': \"Interleaf was a company that had smart people and built impressive technology but got crushed by Moore's Law in the 1990s. On the other hand, Viaweb was a company founded by the author and his partner to put art galleries online. However, they realized that art galleries didn't want to be online, and they pivoted to building online stores instead. They developed software to generate web stores and transitioned to creating web apps that allowed users to control the software through a browser, leading to the establishment of Viaweb as a pioneering web application company.\", 'role': 'user', 'name': 'paul_graham_agent'}, {'content': 'What did Paul Graham do at Interleaf', 'role': 'assistant', 'name': 'user_proxy'}, {'content': 'Paul Graham did freelance Lisp hacking work at Interleaf.', 'role': 'user', 'name': 'paul_graham_agent'}, {'content': 'Did he work well?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': 'He demonstrated a strong work ethic and a willingness to explore various projects and opportunities, which ultimately led to successful endeavors such as writing essays, developing spam filters, investing in startups, and founding an investment firm.', 'role': 'user', 'name': 'paul_graham_agent'}, {'content': 'Did he work well at Interleaf?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': 'He was nervous about money at Interleaf as he sensed the company was on the way down. He decided to write another book on Lisp to secure his financial situation. Ultimately, he chose to drop out of RISD and pursue other opportunities.', 'role': 'user', 'name': 'paul_graham_agent'}, {'content': 'Did Paul Graham like eating burger?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': \"There is no information provided in the context about Paul Graham's preference for eating burgers.\", 'role': 'user', 'name': 'paul_graham_agent'}], summary=\"There is no information provided in the context about Paul Graham's preference for eating burgers.\", cost={'usage_including_cached_inference': {'total_cost': 0}, 'usage_excluding_cached_inference': {'total_cost': 0}}, human_input=['What did Paul Graham do at Interleaf', 'Did he work well?', 'Did he work well at Interleaf?', 'Did Paul Graham like eating burger?', 'exit'])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "from autogen.agentchat.contrib.graph_rag.neo4j_graph_rag_capability import Neo4jGraphCapability\n", - "\n", - "# Create a ConversableAgent (no LLM configuration)\n", - "graph_rag_agent = ConversableAgent(\n", - " name=\"paul_graham_agent\",\n", - " human_input_mode=\"NEVER\",\n", - ")\n", - "\n", - "# Associate the capability with the agent\n", - "graph_rag_capability = Neo4jGraphCapability(query_engine)\n", - "graph_rag_capability.add_to_agent(graph_rag_agent)\n", + "from typing import Literal\n", "\n", - "# Create a user proxy agent to converse with our RAG agent\n", - "user_proxy = UserProxyAgent(\n", - " name=\"user_proxy\",\n", - " human_input_mode=\"ALWAYS\",\n", - ")\n", + "# best practice to use upper-case\n", + "entities = Literal[\"EMPLOYEE\", \"EMPLOYER\", \"POLICY\", \"BENEFIT\", \"POSITION\", \"DEPARTMENT\", \"CONTRACT\", \"RESPONSIBILITY\"]\n", + "relations = Literal[\n", + " \"FOLLOWS\",\n", + " \"PROVIDES\",\n", + " \"APPLIES_TO\",\n", + " \"DEFINED_AS\",\n", + " \"ASSIGNED_TO\",\n", + " \"PART_OF\",\n", + " \"MANAGES\",\n", + " \"REQUIRES\",\n", + " \"ENTITLED_TO\",\n", + " \"REPORTS_TO\",\n", + "]\n", "\n", - "user_proxy.initiate_chat(graph_rag_agent, message=\"What happened at Interleaf and Viaweb?\")" + "# define which entities can have which relations\n", + "validation_schema = {\n", + " \"EMPLOYEE\": [\"FOLLOWS\", \"APPLIES_TO\", \"ASSIGNED_TO\", \"ENTITLED_TO\", \"REPORTS_TO\"],\n", + " \"EMPLOYER\": [\"PROVIDES\", \"DEFINED_AS\", \"MANAGES\", \"REQUIRES\"],\n", + " \"POLICY\": [\"APPLIES_TO\", \"DEFINED_AS\", \"REQUIRES\"],\n", + " \"BENEFIT\": [\"PROVIDES\", \"ENTITLED_TO\"],\n", + " \"POSITION\": [\"DEFINED_AS\", \"PART_OF\", \"ASSIGNED_TO\"],\n", + " \"DEPARTMENT\": [\"PART_OF\", \"MANAGES\", \"REQUIRES\"],\n", + " \"CONTRACT\": [\"PROVIDES\", \"REQUIRES\", \"APPLIES_TO\"],\n", + " \"RESPONSIBILITY\": [\"ASSIGNED_TO\", \"REQUIRES\", \"DEFINED_AS\"],\n", + "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Revisit the example by defining custom entities, relations and schema" + "### Create the query engine and load the document" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Received notification from DBMS server: {severity: WARNING} {code: Neo.ClientNotification.Statement.FeatureDeprecationWarning} {category: DEPRECATION} {title: This feature is deprecated and will be removed in future versions.} {description: The procedure has a deprecated field. ('config' used by 'apoc.meta.graphSample' is deprecated.)} {position: line: 1, column: 1, offset: 0} for query: \"CALL apoc.meta.graphSample() YIELD nodes, relationships RETURN nodes, [rel in relationships | {name:apoc.any.property(rel, 'type'), count: apoc.any.property(rel, 'count')}] AS relationships\"\n", - "Parsing nodes: 100%|██████████| 1/1 [00:00<00:00, 15.55it/s]\n", - "Extracting paths from text with schema: 100%|██████████| 22/22 [00:18<00:00, 1.22it/s]\n", - "Generating embeddings: 100%|██████████| 1/1 [00:01<00:00, 1.02s/it]\n", - "Generating embeddings: 100%|██████████| 4/4 [00:01<00:00, 3.92it/s]\n", - "Received notification from DBMS server: {severity: WARNING} {code: Neo.ClientNotification.Statement.FeatureDeprecationWarning} {category: DEPRECATION} {title: This feature is deprecated and will be removed in future versions.} {description: CALL subquery without a variable scope clause is now deprecated. Use CALL (e, row) { ... }} {position: line: 10, column: 21, offset: 397} for query: \"\\n UNWIND $data AS row\\n MERGE (e:__Node__ {id: row.id})\\n SET e += apoc.map.clean(row.properties, [], [])\\n SET e.name = row.name, e:`__Entity__`\\n WITH e, row\\n CALL apoc.create.addLabels(e, [row.label])\\n YIELD node\\n WITH e, row\\n CALL {\\n WITH e, row\\n WITH e, row\\n WHERE row.embedding IS NOT NULL\\n CALL db.create.setNodeVectorProperty(e, 'embedding', row.embedding)\\n RETURN count(*) AS count\\n }\\n WITH e, row WHERE row.properties.triplet_source_id IS NOT NULL\\n MERGE (c:__Node__ {id: row.properties.triplet_source_id})\\n MERGE (e)<-[:MENTIONS]-(c)\\n \"\n", - "Received notification from DBMS server: {severity: WARNING} {code: Neo.ClientNotification.Statement.FeatureDeprecationWarning} {category: DEPRECATION} {title: This feature is deprecated and will be removed in future versions.} {description: The procedure has a deprecated field. ('config' used by 'apoc.meta.graphSample' is deprecated.)} {position: line: 1, column: 1, offset: 0} for query: \"CALL apoc.meta.graphSample() YIELD nodes, relationships RETURN nodes, [rel in relationships | {name:apoc.any.property(rel, 'type'), count: apoc.any.property(rel, 'count')}] AS relationships\"\n" + "/home/mark/miniconda3/envs/ag2neo4j/lib/python3.13/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "Parsing nodes: 100%|██████████| 1/1 [00:00<00:00, 321.70it/s]\n", + "Extracting paths from text with schema: 100%|██████████| 3/3 [00:29<00:00, 9.92s/it]\n", + "Generating embeddings: 100%|██████████| 1/1 [00:00<00:00, 1.41it/s]\n", + "Generating embeddings: 100%|██████████| 1/1 [00:01<00:00, 1.19s/it]\n" ] } ], "source": [ - "from typing import Literal\n", - "\n", - "# best practice to use upper-case\n", - "entities = Literal[\"PERSON\", \"PLACE\", \"ORGANIZATION\"] #\n", - "relations = Literal[\"HAS\", \"PART_OF\", \"WORKED_ON\", \"WORKED_WITH\", \"WORKED_AT\"]\n", - "\n", - "# define which entities can have which relations\n", - "validation_schema = {\n", - " \"PERSON\": [\"HAS\", \"PART_OF\", \"WORKED_ON\", \"WORKED_WITH\", \"WORKED_AT\"],\n", - " \"PLACE\": [\"HAS\", \"PART_OF\", \"WORKED_AT\"],\n", - " \"ORGANIZATION\": [\"HAS\", \"PART_OF\", \"WORKED_WITH\"],\n", - "}\n", - "\n", - "# Create FalkorGraphQueryEngine\n", + "# Create Neo4jGraphQueryEngine\n", "query_engine = Neo4jGraphQueryEngine(\n", - " username=\"neo4j\", # Change if you reset username\n", - " password=\"password\", # Change if you reset password\n", - " host=\"bolt://172.17.0.3\", # Change\n", - " port=7687, # if needed\n", - " database=\"neo4j\", # Change if you want to store the graphh in your custom database\n", + " username=\"neo4j\", # Change these as needed\n", + " password=\"neo4jneo4j\",\n", + " host=\"bolt://192.168.0.115\",\n", + " port=7687,\n", + " database=\"neo4j\",\n", + " llm=OpenAI(model=\"gpt-4o\", temperature=0.0),\n", + " embedding=OpenAIEmbedding(model_name=\"text-embedding-3-small\"),\n", " entities=entities, # possible entities\n", " relations=relations, # possible relations\n", " validation_schema=validation_schema, # schema to validate the extracted triplets\n", - " strict=True, # enofrce the extracted triplets to be in the schema\n", + " strict=True, # enforce the extracted triplets to be in the schema\n", ")\n", "\n", "# Ingest data and initialize the database\n", "query_engine.init_db(input_doc=input_documents)" ] }, + { + "attachments": { + "neo4j_property_graph_2.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Property graph screenshot is shown below:\n", + "\n", + "![neo4j_property_graph_2.png](attachment:neo4j_property_graph_2.png)" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Add capability to a ConversableAgent and query them again\n", - "You should find the answers conform to your custom schema " + "### Create Neo4j-based RAG agents\n", + "With the schema defined and data loaded, we can now create a capable agent!" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[33muser_proxy\u001b[0m (to paul_graham_agent):\n", - "\n", - "Which companies did Paul Graham work for?\n", + "\u001b[33muser_proxy\u001b[0m (to rag_agent):\n", "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mpaul_graham_agent\u001b[0m (to user_proxy):\n", - "\n", - "Paul Graham worked for Y Combinator (YC).\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33muser_proxy\u001b[0m (to paul_graham_agent):\n", - "\n", - "who did he worked with?\n", + "Which company is the employer?\n", "\n", "--------------------------------------------------------------------------------\n", - "\u001b[33mpaul_graham_agent\u001b[0m (to user_proxy):\n", + "\u001b[33mrag_agent\u001b[0m (to user_proxy):\n", "\n", - "Jessica\n", + "BUZZ Co.\n", "\n", "--------------------------------------------------------------------------------\n", - "\u001b[33muser_proxy\u001b[0m (to paul_graham_agent):\n", + "\u001b[33muser_proxy\u001b[0m (to rag_agent):\n", "\n", - "Give me more people he worked with\n", + "Tell me about sick leave\n", "\n", "--------------------------------------------------------------------------------\n", - "\u001b[33mpaul_graham_agent\u001b[0m (to user_proxy):\n", + "\u001b[33mrag_agent\u001b[0m (to user_proxy):\n", "\n", - "Trevor Blackwell, John Collison, Patrick Collison, Daniel Gackle, Ralph Hazell, Robert Morris, and Harj Taggar.\n", + "Employees at BUZZ Co. are entitled to one day of sick leave per month for full-time employees, which is prorated for part-time employees, with a maximum accumulation of up to 30 days.\n", "\n", "--------------------------------------------------------------------------------\n", - "\u001b[33muser_proxy\u001b[0m (to paul_graham_agent):\n", + "\u001b[33muser_proxy\u001b[0m (to rag_agent):\n", "\n", - "Did he worked with Joe Biden?\n", + "And vacation?\n", "\n", "--------------------------------------------------------------------------------\n", - "\u001b[33mpaul_graham_agent\u001b[0m (to user_proxy):\n", + "\u001b[33mrag_agent\u001b[0m (to user_proxy):\n", "\n", - "No, there is no mention or indication in the provided context information that he worked with Joe Biden.\n", + "Full-time employees at BUZZ Co. earn 10 days of vacation after the first year, 15 days after the third year, and 20 days after the fourth year. Part-time employees' vacation days are prorated based on their hours worked.\n", "\n", "--------------------------------------------------------------------------------\n" ] @@ -393,10 +307,10 @@ { "data": { "text/plain": [ - "ChatResult(chat_id=None, chat_history=[{'content': 'Which companies did Paul Graham work for?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': 'Paul Graham worked for Y Combinator (YC).', 'role': 'user', 'name': 'paul_graham_agent'}, {'content': 'who did he worked with?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': 'Jessica', 'role': 'user', 'name': 'paul_graham_agent'}, {'content': 'Give me more people he worked with', 'role': 'assistant', 'name': 'user_proxy'}, {'content': 'Trevor Blackwell, John Collison, Patrick Collison, Daniel Gackle, Ralph Hazell, Robert Morris, and Harj Taggar.', 'role': 'user', 'name': 'paul_graham_agent'}, {'content': 'Did he worked with Joe Biden?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': 'No, there is no mention or indication in the provided context information that he worked with Joe Biden.', 'role': 'user', 'name': 'paul_graham_agent'}], summary='No, there is no mention or indication in the provided context information that he worked with Joe Biden.', cost={'usage_including_cached_inference': {'total_cost': 0}, 'usage_excluding_cached_inference': {'total_cost': 0}}, human_input=['who did he worked with?', 'Give me more people he worked with', 'Did he worked with Joe Biden?', 'exit'])" + "ChatResult(chat_id=None, chat_history=[{'content': 'Which company is the employer?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': 'BUZZ Co.', 'role': 'user', 'name': 'rag_agent'}, {'content': 'Tell me about sick leave', 'role': 'assistant', 'name': 'user_proxy'}, {'content': 'Employees at BUZZ Co. are entitled to one day of sick leave per month for full-time employees, which is prorated for part-time employees, with a maximum accumulation of up to 30 days.', 'role': 'user', 'name': 'rag_agent'}, {'content': 'And vacation?', 'role': 'assistant', 'name': 'user_proxy'}, {'content': \"Full-time employees at BUZZ Co. earn 10 days of vacation after the first year, 15 days after the third year, and 20 days after the fourth year. Part-time employees' vacation days are prorated based on their hours worked.\", 'role': 'user', 'name': 'rag_agent'}], summary=\"Full-time employees at BUZZ Co. earn 10 days of vacation after the first year, 15 days after the third year, and 20 days after the fourth year. Part-time employees' vacation days are prorated based on their hours worked.\", cost={'usage_including_cached_inference': {'total_cost': 0}, 'usage_excluding_cached_inference': {'total_cost': 0}}, human_input=['Tell me about sick leave', 'And vacation?', 'exit'])" ] }, - "execution_count": 12, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -406,7 +320,7 @@ "\n", "# Create a ConversableAgent (no LLM configuration)\n", "graph_rag_agent = ConversableAgent(\n", - " name=\"paul_graham_agent\",\n", + " name=\"rag_agent\",\n", " human_input_mode=\"NEVER\",\n", ")\n", "\n", @@ -415,12 +329,9 @@ "graph_rag_capability.add_to_agent(graph_rag_agent)\n", "\n", "# Create a user proxy agent to converse with our RAG agent\n", - "user_proxy = UserProxyAgent(\n", - " name=\"user_proxy\",\n", - " human_input_mode=\"ALWAYS\",\n", - ")\n", + "user_proxy = UserProxyAgent(name=\"user_proxy\", human_input_mode=\"ALWAYS\", code_execution_config=False)\n", "\n", - "user_proxy.initiate_chat(graph_rag_agent, message=\"Which companies did Paul Graham work for?\")" + "user_proxy.initiate_chat(graph_rag_agent, message=\"Which company is the employer?\")" ] }, { @@ -432,90 +343,85 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Parsing nodes: 0%| | 0/1 [00:00=1.0.10"] -neo4j_graph_rag = [ - "llama_index==0.11.8", - "llama-index-graph-stores-neo4j=0.3.0", - "llma-index-core==0.11.8", +neo4j = [ + "docx2txt==0.8", + "llama-index==0.12.5", + "llama-index-graph-stores-neo4j==0.4.2", + "llama-index-core==0.12.5", ] if current_os in ["Windows", "Darwin"]: @@ -122,6 +123,7 @@ "ollama": ["ollama>=0.3.3", "fix_busted_json>=0.0.18"], "bedrock": ["boto3>=1.34.149"], "interop-crewai": ["crewai[tools]>=0.86,<1"], + "neo4j": neo4j, } setuptools.setup( diff --git a/setup_ag2.py b/setup_ag2.py index f40dd99e27..f1653a958f 100644 --- a/setup_ag2.py +++ b/setup_ag2.py @@ -55,6 +55,7 @@ "ollama": ["pyautogen[ollama]==" + __version__], "bedrock": ["pyautogen[bedrock]==" + __version__], "interop-crewai": ["pyautogen[interop-crewai]==" + __version__], + "neo4j": ["pyautogen[neo4j]==" + __version__], }, url="https://github.com/ag2ai/ag2", author="Chi Wang & Qingyun Wu", diff --git a/setup_autogen.py b/setup_autogen.py index 68bf0050b3..274f3ec417 100644 --- a/setup_autogen.py +++ b/setup_autogen.py @@ -55,6 +55,7 @@ "ollama": ["pyautogen[ollama]==" + __version__], "bedrock": ["pyautogen[bedrock]==" + __version__], "interop-crewai": ["pyautogen[interop-crewai]==" + __version__], + "neo4j": ["pyautogen[neo4j]==" + __version__], }, url="https://github.com/ag2ai/ag2", author="Chi Wang & Qingyun Wu", diff --git a/test/agentchat/contrib/graph_rag/BUZZ_Employee_Handbook.docx b/test/agentchat/contrib/graph_rag/BUZZ_Employee_Handbook.docx new file mode 100644 index 0000000000000000000000000000000000000000..c527b85e3685fa8a99fb3a6673362e32ed499678 GIT binary patch literal 13226 zcmaib19&A%w|1O~ZA~z-ZB1-WY}@t@CblQGZDV3*Vq;?4$)7nN&YW}qd+yp#^|QOH z-_^D1?Y(MO_1kiipkSy#A3l5lf&z(91NzNi-oNYE8(BKg(f-<&Pj^dzG9W^1cx39Q zc(^nu3mMk72Ty(z^YV=zJ%#utC03xmz9t9VBKM^mpXp(5k2r4?_oc(VFdh#QytKtH z6rgw1leOV=SJ(Dcy3tg}v@&1la$mnlu734(MGIS1K(>0mB+&*1O(xAhnU+#10#iuHl~!YVI`_E zP!w2^ISFxu@Z`<=ASA3IBeON_lv84JCC5_DX?Y*8O)_|!R-aIeUVYshatkf9gw8V=(J6#Ohy&91bT(dRgM=us66zw=Kb9l6jqg9a7)~~fR$_hL*jwDWh9{U1gZMS*b85_Nh zm(~wnhEu_<_txq#CzuJx)KA13x^O?LMKK^Fy|l)M=R0Sqr1X;mFTSZ$)L+{h^@*UWzoiP z7s(pex~g309w3aT zNN{;@-L%3D!h`gzE*qBFLka};$7jz6Hd$!8qp?J^{9F_;f`sf2J+&f|&}QS+<^`tB zaP^o!LTp7Yo9B{SY{xR=FG0lO6qywlm#oC^SEMf+w8cl{YzeYXoY7UhVQ|R4>HLKJ zMMSb3O1R`Z5yJmS1j_G37&tjN+F1R;#dtOJI~ReQtA!sHmz5x6rt8Akxs>jr*BXEw zYzC#nygY~jr;%R?cx8U@ynHT0TtqT&rlX<&qJe`aqp^9(XBY1t+R()h$l8IRZgrm5 zBnA&20uH18Xu(m4YM#F^z5$oSVL(ePY@?82r@$OJ-ji~?1sunzG%LRti1I+>$?$U!se5JshKISmXd+Lwqx&66Z*5VM?1{+At~2L)n1L%aHnz zo+9Fi1bm;;I-heG`hg^JZ{>#N;JhwL@{9nN<8O%ak6M`SE>qnTl6!352sS&5*YH;zk|>*d^t`o+G3;>sE2 z6tT@kiGu)*`;z&>is7z1r^l`1%FExH=hn;;OoT1O@6)D8HGPJe(yC#GTt8MOv0MT|A9UV`af^Z%$yc@xsDlURr}2p110rA`Vbc{>Rh@@04`A1wpuxC-@E z(Kp+GLkSSGcZ^6 z=m6f6yj7*^Ww=K2zA}2L?!jvrY&*d99OdV`6=!G0$ks{m4~AX3KRE++{75mwq_W^y z%9vl2n}tL5YPabKC#vOf%@-LO^aEuKp}p3R&LmS$8h}EXk}a$qXlNIFcyB7ff6z}M zcQI@Y(T#qFDbNGL*~Rdkj1*_*J&h7o=@p<)MevyKeUPlt!fquWGAqKh0uEx?%m@hKdYToWRNODr}a-1kZXUxf%x z;)-V|T`ZOUi->QX@AM5Xe<*Mv#MM^;9f+l(8%V7#17ymKW`l375rB;1MWqk1QF4?h z*f_$AlzufU62OAC8;{`qU+o)Zc7Tz{ljVqZ7=laUixSje0m5ejK?X>ep4j~ysn*nr zSj;7gD#FCiHXNe(1ta&>Q-ISlHvqoXDQgM@!9RuAZs};^>x=H(hV^}L);Bmi zp2d&JH-)`WULudi?G{Vz{@*rD*}uu+XghsGOG=gYH%?g=)l@*V-2SGQsRfa{Vb1OX z1O3gJLHGl!IIf%v-nF&==jr~dyY87W9lvgo5HQNZ?(<#bTiXrQb2J!U8NgJTT8}T( z1VFsfu55klc@*OZlFXmh$4d1v#^19?VD7*OHH&;bo=nUhWPBD2B>J>+c9dq3p-y;s(UvfcI?0ssVMiip z|1^OTgaymM15*~wC3|o%uy^b)JMa*{( zU?JFQXy@Xl$f^my8KSy<1dRSmBWk#7fFpK70TFHCcVUK@o(-9R<^&D-IU{ZfL&}Ii zbyX5Ge+{h0Srbq4@&yZC2%VsPJxI%@2Tgi>;xo+nqQJEW!b7)u9=o%b-961kKJ+Qq zyA$p2#%h7Ax@;>5ne+M=TUqMV^ln|?y5=u@>YbmuUc(_P(3)N~)_3v{UG9iTdgyU3 z`SW+MZP9Cqwl4x`fQccZkwrfUVL1Ck1KH>{=Q(jBvSmvkn?YH9VYqM@M{xEXX3V$B z(4T|tLGMk+-2PDmyI%j<$1P+1Mn#F2e@C&)0UNx^fL75UH5=|<%R6DF{cG+I(B#1Hk5uRa#&Xi;d<>*1k_#4fTyS)$dh=2(Pes!ZQ+DGt;%ArG^>kg| z9hnF9t_cWC+TEoT%1Wt0*HEUfyE_(VOK6Pt1=l0@h$kzwExoV2;Q`)h=NR?=25C+nW zL~`+-x-7afQCAGX(+(F33mpfGd}J!x;Vnra(%)*L!@} zF2n^S$|w0v4FRnYH=+rhTqvl5&!Ym$AU9A(A1RK(>S;fp8nX(jt_z*^#P1KTQ0zL= z=@9!b@mendoY;AJM{_K}@B0tb6V?Q18WfJx__Avr`QJ|SDMZAcV<>8LwbT?{dl;bA zqEdZ1z9wp0r=>>|V&3U`X3!H;Yf#}oHL(Jz=2?($Z)mXN9W_eSfq7=irdxp%rRU0? zFIdY|?nqSWncGJsTg-^i@+_Oz_ZWu3$?r4D3z;8yW);Q>hE{9FSr`Yl&=ph1F9IGv zd6lm0dm0Trff(fnSpisZYe_{kMLsQ8!_l@{76@|NaDX~!Z=;d05ycV?Qoad@tV1B$ z(io95wG4Lk0mJnj%%zgi$R9k8Q^Dc%fV1oA$4ce(6F@?Ir<+#Sd|6%?PKbg*%R;n* z-V=6rC)c`_962@6BwU@HQnAaR{$%3j^%EccgugFqq@YLQ1UZtFK^8~rY%OslIj->{ z4D-r`Zrn#w0><>a-L)4SXne4kyGwV+lue{C60nAz9H9-)9(-5BhRePe3N{-mWkeA) zYsafW`~oJ}qG>|qP}vl;p(RNUw`2HlOT1j?wQvnYkm+I-{MpTiL6rJKF^`wiDJf@MGWN3ANSSx|CAeOSqoPvwb zAtUjrrIRUULTBB_oJ~R0x=&uc-Bnd<2OAcGdddi;9AE8Gok*67AE@O(DkyV-1)}2{ z8b583OzRw$GvxB^(3m<{KZl3gTsH)=H(6X8kNVF5_|LvH3(wdchF`B6qq8vAHsAs<$<4e8F?b6@r}gL=2w@YP)i`KhC`a_MVw(}Kw79j%5bBl_`t(_TOE`AMU9&O2ii=Po$Yg@v28@kVL_q73m$d&U=NX41@{aSmF8Sq=H0qUE|0#e4 zlv0#DBZFJt3Bv!w0e0=I>o7o--QNO8Ng*SD)D?^mW=U&2+0iUvjqc&}&FF z$y1)n3<-=vi*)Tj@Gq#Us53N$ezScM<@R8ocROxXkBRiFv)=O_h-ojbdk7 z-tBvaQH=m0208ZM2-xkAARZnwor6&deLxeFsAoEs04f9vZ!aA(NuoTpp|=|9e?l6C zAv~u}Yvlo&8#&?{qs4sC)D=!si-~#gu38MO+miqjX?9TWF8MNqT0;Z#kWyNyzUhcyNo+&B z6|FgF5O-LZ9Hy4<$maIEuUbDpq9-MRx!mhRZD=kTd80uJ zg`$|rzu?=nIV^Wp17{bWX(0+Unt+1DgwxM(6j1G%S#NC4ah+x#D3uvne0Dv&)&Edr`mr9okZ~)x-^Ake+CJ$u9u&=R`9-jl67Thh^2e;P`GN`t&7}c3vf5 zN3DYWGLHpAG_ElyE;%N;7JsV<8EYMb!5GiL-=-CKmwd>(oZRJz7}X|bf^bXW^lOrlb=Ujx5jbWk03 zzVX2>7;@)b#bKOUr!|V2h@J;-nc75+ucy6aj!K>lmC8Ii#(dKD_IzWhMmWRrcI5Rt zP+K44rTUs2%Ebjd$#GbFb4+k<2np(bv4sX_3!16(_ByL3zY%0{&w@?`gP`5ai0vOa zJMUy|rl9H7oqHLktfp+4ucT~QT&5i2v)_unGqe)ZB9ZkV7Eq%JKO;(t-B3s{5IWG0 z(9;vWqBIHfymF;Fk#uU8*W;otGCBsz+PdXt8S|m-(v8UKgMs%$&>)DS?1b)4_DX3j zUmJ)0h_ckq!FVUnW1TzQ6T%zluho{D6(4lE_r;VIuYX#LLio>Wi-V(^rIEw0HK>zx z4VUF6q=EG(3fJoyUPGs9YA%kW)opU|bS<)rinLQEAwl#xlI%<5ftPD=egz^Hus&du z)uarb!U&47D4ufdwaUa8BY+(@)!{m+GJFSEK@JHV?`&+?kPx-os7ocP%>ZLHdiG$3w1J5B&(4Q?#F2pV&$Ak{8B?+)m44Uj7jPrJ)U!UM zF5(X+4@nQ52#n(jX9sYSUW64Q^C7w=TCz3`^LFZQ-)fm#Wx!jpY1GK)LM9UMDM zN+3(nV&vdjrsAhmGbvu89>>|xwIhsc4+j}}c+qR_vpM^>RdiIw9L^BRg|pNLVpU2l ztk`L}n0ZfkPw(j*wmcgp<1^;nNNqA)H1N-sV?J@v`L!aeiiUR=1yOI?HBhcdcnz~P zPW$}qrc@-*j3CY3+L(`W35gDgJvP67baJ!pBeo+3_zu+5^=lxV^C^AnDBxzteLL~D z3%vBDyHb65I@Z^VhySth;*xpBh=y?ZBiRg?*8((GiWZ)XZTGE0_lNz=@^NF@f$wF( zK=8cj_cFAYxfY$YpG9Yi*CFHDheB6LoKp{y>82M7WG$}6C|VseA=+=VWXN`1ofv)# z{_den#9L`dcDq7p4n*UCUPhKqG-l;tjP^AjA2Io?cqKIG6vQ93=Y8og=9P#(T=e| ziiQpLMEFuyDGxZVV(TgSXPy}cf@5(wHpKY$$|11U>`|Q;a#G|jU z)V!O}4$iBm5znmfgVKU;Qu_N~EnKa1>3bzX{js#MFh|dOvI?+f5fhkmVkpgoK)*}} z_m`i`me^6532pzelLtr8=n)h6?25&B(&^F&Ya|hK{$-2M*c_PNvxVYLs+}vb>TAGB zL&lmLgch!6MkAx^?J31>9Z!h4mW`%iu{+I{=e;khsZw|S9#Y_ZhA678$J#mKQ(oeb zyPxxC#fh>@r#bApmr?*4%$2?X7x$7X>q;*?@VNj9g&Jm^0TlOrt@ijDBFznaIqq5& zsD-O4p2?@_-2^efm!N5%Jn>$(39gKynqxcq1Ao}h58pvKwUnaec^}{4?S~NBjbpn zP(QT`$lEKV&YORM-+al3$jlIT59vA{LtRM$`XN*jEX0@@M#b*{LwJ@porf#+8j`H+ z)lY3rImFvS-_gRH3Ez`t+kM_8Lbv(g`D-6?_FZ5R;4lO1%QCCf)lKFKLB=7kWR#)F zzGOzqi)if(o;Ea#ZEq43+{*bUfV`qK!jcaZ=W-X^nI)*`?4r@&w9>s{d%3I9YPsvo z3!e6K0yoyMVcb_oP*va|kt&c_xNO)fav2H_OVd_TV!X!>X9bZpCeBTklua|4VIDl??3g;R)E^%J`a_ zXRUmgZVN?0P~K%TcC2+y2owH^VNa|H(a)!7K6(J$G{8A&Frs6RzrRm-1$AW6GhLpx z0R}f=(C3^*?FVyMjTRVJ4mE5($&v<_6nlS-8^baMlY>wH2I)%R=$-}^1b6jyajmxY zNiyBWoY@(!U#7i%B9+T^slGU(f&#RHUvhzI>Sz1t8-qNtLfo>CJGlb49@ zPc>l=X4}0IIeKnuKaevV?3OO8B&=1nuj>N#+K$bjXm7O~`+B(&xf?ipgp=NmEx5z3 zv>adQb+8&U8b)Gn6W^c7Ozj9q$X!%;>Aa}}%^qMdIX`)K8#E3G#iRqE$hh)dG#8Py zfN#0pNT=s`4pBON&MGs2+%^RTsF^pX_w3r41F)qoN|O9 zctwbQ@Jhk_kd#7MptE*XHY_gCN@4x6MASmkwz$xoopp?Yy-pg;5@0a`K zTM&#=&aYYVFD`BQ=o$a7>!A_-&vpWEj${0wPwd`{)_VY&e+fbm>_2UWR?%D-X#`@}&MvQ8KB+p5 zx7OIKB1`#SRpeQ0)wGZcON(|jQH{-n7ouNPSZXnS{k)QpYY}7{(8}mAh6rz~!dror z;las4ppkipTiEydsKCE(KY+d2BeQQWS(M;p)7fb1EU0sH9MHkI1VzqMj@ee_jH<53 zH7sq8X{=hj3OXy(B>@K|qW~J-I)k`F%_7t+4u?Yg#aygQ;v^&O1dOa0xL?aW*gg?E zXC*I45$lf{I4IR(NSVPezhN+3REr6LsaQyK^Mn2hf>35u|K;u%h_GAS+}AD%J0~qa zsED?Bj5gGxUWsXdrpG*}398vRSaO`@^H=j?;}cby*$Lp>jUub4$9ZC}q z8C#Sk`DGi;iZS)$=hiF+U)Xn3Tc;r?~@>z@RW@DAjHS1?6-j5!}W2?|C=JzX0 zS}AP*s$7k$)u=a2ct7eS5mB1R`K!wL9is4Urpdfm`WKG$rVDDZ{9n*NPCEV<^!Jng z4-fBGuKBO~^j~n%7Tu}Vul~G{FSQ}hP;oMGdfaes0e|x>{ewOTM2Yql%0myny;D`uUZ{FN8(_Y z;_JQXgOj-PbYP{Hl3%66JfvpjUsiI~9bT-N6HRtwwjKv(O`Wa1nYE7!?Jq7@RW0K# zgzAf0-1lTVdxAXU5>{z7F1G08ubfnsP8hrxz7n`06S%wvYBw4y1r9%Hd}`O>ktkE> z@ceN8O51RV)P?7*>ty-0D%dLo$)uK@)8F zY0S+BPv_Ibb58@1Da^;Qs}dqcHCPuKcEsi ziHNHiCQUrun->gK&^aw$CsgJLPX!_=dJD9oiNlBgK{cz*Esv2E!$;=Mj@y)FFrQV;u@yhnoB%!X0=4a z7>-@KenXf`06KNQZqF%qnYPaeae@>|TCFY}?A%^p{krtnysWAxIx6R-SgnchB8GDzyJkSwuH%5 z;=@9VAqci(Vl&YkrqE)P8LkT;xjZ&skpGlbxdSY#rr#p&P;u;^~j_c?xfn50- z9pEbDt%X5Q$ODRu`{9iX%9;zR59Yc=#U1xHx&)Hk>6FmzYf1*`!QyhtLHbB81j`qd z$1BDTz0Vd1>;x-ImU!rEd9T$!_3lH^e1_8Xc@iqrm^tsqB_85M(KBVpl4vq3!{$j; zPf%(zt--^;MPQxbxM5Bl>Kw?vf&ZH2amnTx7sCMot^57cED!BJvph#rBP%1iKeh~i z%=Of?Du1wIcC1$h+v{AW*NI+dv0CYEba+pmsv!3XS zwJ!J7!9nG%R_Qpf7DR|Y2Xe^prOg4ehJI&OFOE3b^Ln}WIvJ3$f9){~tv5(k6sl>k zPG@q0Ge*M7rnWv}gNKYL@YcKYzta8si9Qfp)Wi|8?k1pmC{k}SSOwHQQcAafxt~N9 zc)O3ARfL0mQ~P~kzTg0df!Y?zBo2;%LaBNBtZ=qECq++3gS)nB=AN?tFEu#96D!u%^qe(; zTKEV_K@~^M-X;g@v@bSWj{@swPm(?$KsmutGfQ3Wt6v)T#;TEv+LZ23!FdKsHa@+L zLv(DTtwXP=ZLY#S>mpX@llu)z$|A*e!LLHEX>7j0dFnd5Tg!FB$N}V?>-<=G)}b(R zwFLXYbQF3tGPph*b9e?a<}E5OnUq;qsh6(48caqJ% ziDCo7DCkyi_6_vMW@q0#nhFt-E+oiMOIhf?h;p}Ru6!hES-H>m_Cw^KeLo1axxLEL zS3T^V&-QAc?j}xO@~T?EYE&ECUsv~hc%Frxt}YrU2t14X6|vryqcUF~M=;Dk#`#Tj zxL-fTiB5F99!H%KkZ+{p!W!KZN)XOgbfKJZia&Ir;&ti0PEf<6_!@@EpesiE^@#YL z*5&~^7(p?~ZM9S*HpbFM0-#;(+*<|jKMobbQurpt)q$*#fw_oR;QrXjq2qx5LH)%g zL)K`;2`Ez8>#N1Xi7c6C2XVp(y&qcYJiRPOupUIpm%13@4`{}Xh$Y{h2!uJZ4M*!V z#EwAnV222?8SAG$#b36KDuKCmP*pE>7CS+GX+G=Tri`tG_En}OtO&RuN@k3v#PUZS z8RY3gMjP^1!&e58!J2S{Wte&-7Aqd!HRmmzY#-ebPQUfymMk4i%O*y%M?fSZ_V`II z#m^~kFQP_dz?UcL847ZOttWw;*CH6oH~~6n{=*AJ;C5o}7OtY~5K5s=%3(IvH?IZX z#1&STbse12JtOBhVXK4mXl*&ci8gPd!|k2``C2A2p2}RS|H$@e3oq6)V9o2~)X&Tr z?sDf+yJcPS?oGbsXzuD3+#`P~$WsZ!dV0y>2~*Fr%NX-iKKnEt!G?JwA?IUwVk1;s zfX;Yp>Bbgrumug-vBCFPe=sRmw#0qH0*85qS<-;Z7lFzfn%g9^7FiLaawD2ksb*l^ zQumHd>ca=?@5AbRs;dB+)i4DqBajT+$48R9@e&eT@Q^My9^}Mk8gv@)u!0*#^q_dO zj#p+m?w<3NSforFpkDcy!fEfA)pC;-+T>Zi<&2L_|xu)tsa?5G!q5g#Crqx08kP&R#YAYRKI&L9m1eeJjn4Ygx3)$~S8YF2#+^S`pSnBZ62i8Q zNMbI{!XheNZhf|}<;Q)ROH3f!DYIbk}Lu-W!37}nY@Q|CZbsp6>V1K39V zI&nbQ*WrBR;HAKpG)Ak`+y?J~YffuZ54~PX_m`lfCga=#r!0vybk+y{lV#gO0v|zZjPyH8rf-`ODOv zIiHRjjEQ#K>jbErFTLRW8ZYb!Wpz)$fq>kw|7pBH{?B+}Y-8=Hq^EEBhitW7aoHS% z0nzJBC7^A-j5offNg^8+x;(JLyQ_)o2*O^CajM*B9TP27S|IE`adan*i7f8oT9T?k zKy*44fB=bQVoIqYSxb4Z|7!m>h~-AlLT*vDp+Ul%z7p}&R^5*Ra}spfu~B}fMGK}( zW1i)AG8v$0kPbmmVg1Sd=x}@yIs~NUi+;Qjf}lV1Gtl<9U$rzbm1o1OdhUe>;#X+T zWMB0~q)gnIYF@T1|NZ6}G0PyHr#fsY>LT^`nMf*J5x@isqZ*-3Y1v?=?=pEmuX4%2 z6I7;0VUzaLtzoCwNV&Fp!cT0iZ$}jIdBw2?@^m4u;y0v8`#FncLS)|tp@$~~Z-X5U z8^tJa*2V)$6%(3j2GJ`U^`1UtZVa%dC*utm!w~mY3g2oMtjbj2mbFWpmQ?%IU+!50 zV?HX*gUk9%Dd591Kl~wwLoQJ*{Uw6z2Ky%}{ws%bFmiM>vo`r-iMC!*+Gd#^w*5>6 zvxUuB;TTjPJ%Wl%SQ-sz*?PB?ib~!TA{a23NYFXs@0QjoXVyVRB1pnJf>Z%*xaPGOAtN=T zC-^)+u|#39kJ#N1+Y1WqHw+E7&>iNK&W44Ry~ugw=&5KPdXB^Nuo&twg?5w@C=h_d z@UCSVsw@I>1v9#5cel4#VB61oG4C+>X9g%}iwB6aj0gl?(^7Mt!6D8M5AP+o>`AtR z-WA(7A+Hxdi>1?=<5CLZSDa?Heh#OJ?VU|fypif#IT3{&e%B+;?PY;9+Xp`byiA)A zmb0h0`UBpeCebObT=2%6!<$5+c@MqNB4y!Z;hn0G#5WoFAxbQPM}2aXpBr3=n?d9=Y|Vf1=oeQaL`_XZXN}oP@tEL7 zCCju@N-yhnGjkLmT}&p)YDQ8}0e92p&YL%6#oGxh2hY^4xCK`W(zPMK@q`L}7*(Cb zq=-4ZM_p@OvtO!7FVKJoE zMIRx*RO%r2#M4uczFs2PI?SlV%Hd5>-g%#*>vRM6QTdoUL`dTs-$UMV#MFv`I zcQjD6fZng;yNs#xuJ@x@&v`S`+_pNd;S*%%SB%+WVPac>9zCHtUVPJG1$+Le1VM2K zyGfAm)s`KX-9>R1gxiYT^7(wdp~~?VSf`a4Dki`DEGPWgJWs0#mDCg@J;Q+^xRuXpdU87@=5jv z`IY=mtW{ww-^r4J_(c{l2rAH@Z#Dcb=l}Iq!(Z*UcO3o>{9RQ3>&N=15x!sQe`x>z z4*y*W{Y!cNr_H>}Wd95Qw+{X9=-&m$zizTWP3t|Y{1^SFc>3=Se%Ivw(k1_CEbpVl zKdF@e?&f^Rj;xfI0Oa=3=9kiDp;g8$ZrDwdT!tduy$f*dOMa*w9A6CqCl;A zW*8@Xy4I?Tn^rZ4jeV2$_KO)hf%+ydou{+9q72ultkF)ye!sg*p0iBw)Z&q!KnM+4 z-01%)!050ea}9V~-4v=&_tD^Ed9L`yo^jcLVjrAj?494&VQKx{6!KulNv8{)0aiqu z8uv-?^+t;mmZu{>+X-!((tzq3`U01X*yq{Eba7oqJVa`p9<|zdo`KvC`TpYmfXfd( z_X!1Z>}!Crhf|UhPxHOl;da#+IVL_hNI94E9FtV^ zm+k#og3+TX5)ttk^WLD!a?mi_jyK|augxC=0|8O~Upol(^$t@z6J6s<%JZa;0& zBuD70*vXH>Yz2scQqoi>AmTjjkbRvVp7*aJ=Hdl44anrSI%RLv2I6XYN zH|TXUrFETKlpzZuv$;tU%hHDGI0`Fn^Rw)NU`5zeH4Z7zXb+k^Ba)pf3d}X2?(1`- z0er0kU;?)-_qGvIydYdq-^sC}Lpstn%|i7TXnoU~WsQSfM!5T|Nis2pR8#Bx6036jj9?2U4&n^F7iof$NS#GE4K@pO#<9Cw}=b&v~0d;K`qb$ z{Q(hdm#de(=S#PrbF(sQFkaRc{*#B$3GPXwDQtiiN0;DWmgf^K8=q z-<1Y7ieI>GArMjUbCNKmgct>^S&L#Qe^w{na}AHMdt4n8`*GuAmSm7HNX`=~IXwmD zZozN$*#m5MVuEiMF(x_N)9*B)h&OxYIJo3KKV32 z^lc2YA(q7Y-gDQXu|W4noEfUq#^CsV2AJgryl0-K@02(jjg4TZxl9N$?|Pjn_0`o> z&Gf*-v-=6ML0M65mo#)GlHtSc;+;R@OWUUB<>nQ!QG8k~6zrm(r=epqeZ0CkTJVj% zyvmU9`NIz6-$!g^U+p0Fk9I)+-3}%|CucjGKTI)F3HNG>;PvHvnE6FD=-7$s2p)d5 z+nAMFP$#=Sg$Qp?@_>`5P+}p)Nx`RgB`EW#mJQ7Gv>=R#NYspWPq{oY?fq+pL_wL` zPz*m^Wxl2|K6!9Hb5; zUzwVkG*kGc*y*^1T`*R0CfCve$Oc6-*;{Zw>rWqE& z34LC@M-~%CEU4E#pZv~EAI-nsg)LCnoh^dBvnYYPwdn!!t;cBLAq?NVC;|9C_1K#i z{iDZz@2hQ{W!t5C%$8GC6sPw`U?$PWz<`pUBV^xlWc-#RjrbWWToc5HS>(d$WQI*W z5@%_~T0W%btn%jg2t=V%D^jQ3bO@src3%3nIOP!gc&Xx6s*PCbW+)=vB2$S?H!wO2 z3a2$S{<>TV3_lZ{3FfHP$d9kNh$kj~UJsp?F}kc(0it9oKcai`S?GChTm~2AtQI?; zl+*#{25o@GgDSgpPsusdOZ%p%Voq$|azk%yvMoyzXVlr&CWg(=W2yH`=EvLHpORH2 zq0SDm8_x-AwnIk@H1Zbf8ixz%4?p$He{e^ZP@_uMmC?I3MMAbEWf|Yk_-O0oxV~lS zyrnLg-qr1&)hhYJ+=SSg;+Pe4j9*|b)3q`t60czRRPs2v%4YI?@x`LFuFS3HVoVR7 z7RRJyC?~uS3((DryNnBX<9;Ri?BsSj2}5uVQS@u8yQx;u3@R2v5h9#g#Nh%3G;!Wo z!59A-xN|oup@mPWK`m#YNZlHDFk~u8&t%(YwtTAH$bCrcg8yjtr0#Y%S-k3l9(~;6 z_E4vRcV2DzSF`TJ%(KT*$R?f)hHOr%H0yiVTNr-t9=E{^e*> z$Opnl_y+%zM{=`<`t6hwTf zIhCo}75XwQTZ0cwBHT9ZzQGqB`o&@p5nZRc`Qr0<8OMUPP-88vcOAzE=n zB>p`~6I@4>av2#q#{{18SeLGNWWod)WWBZ8_=XfQ_?|{u2sV$XVb%3%{O4{i2fS#O z#KNz|jeauD{<@|VG3s`BQoLbb&R3g4xMo#JcS#74qs4dd@JU)e-$xJFd=!jV6WtY? zWd%@)akUY*Z>d0TuaPXf9BO57F|>ugclu}~xR4&7a5ri(D*j}M5;N)yIwCa_2iYeM zG$WxEQNNSqCyW$Ll7x&QU$o)r^(0&u#ueh0I+chjsw(Z<9(ynpdfM5aOj`A!D3(+} zN@wr}hxeFZxA5M&Ga;Zb-HYT79^A^KM4HpKm7O7jS6BNYJ8k_A&3!a! z;25p5QIh8bq0_hK#8s9!+D7l=2}{4Ek)k@$sofnr8ZE? zwF!+uEwQiz1(1q$oh}#=T(Hgpbp)`~I8w0+G|GHsM1PVGJGDp)vEn1i6ur_NeDZ-UtJ5E6}ABBi&z0JTR>{Qd4>*;rIGyuyb8O%(6&Nz zlY0ENj?`*rL;)2QQZpik;J;vZ0J^ZpXcL`*zGF{{te}sm+o-y%WpM6 z&NrXUm(0dn+I_!+SKkn|^gA|g^!V(z!k}f0f6U3$usn>ywn3~?zJ#V(0^nYW%*@Yx z<8kQg7a$4`O^LT|R%r8Z%TI{33@4(s%chCE9v@tX^IJRWLsE{#EhBTpzhx|4r_WGq+UR{)EE0tuW`DwSb zmzWiG{0CDF-tAqONN0N?jZ_7AZjSz3|FitLG#04JFN9&G6U` zb0T~}9c$>xXYjO0T*LeTex5}h#Mw_sSnHuHxhxHH1j(^|ijehQVCYVG zPmr}QATeE*MxZeW?S@=0AM`RR6nF~+PWRzTGZDZ~hiFbauBX|MpxA?*gE-V`cknRt zX*ixfhG7X#sKS}wLCcYfWM`|8&NSE>Mt_}bD%5352?xSJ5I2>iOg#I^NH_~+1KUZyXm(d?BGWbsq^rbcSG>a?w9&rFWWV1E%h60$z+Uor0sV6$V96(grP4rF^(8LFxHCByv!r}8jEutSGEd; zNJNlUjV-L81?`^kQMJhkCwYi?(UBK=NnnB^EplZt+59pS=Ol^iB}lAg4N7yL=js6f zT~+1iG2jA1jqN92nLwRAX5B!;3}>~JA{$2Nt3GlC(_b+4>>UwvglFe)mIOv%f*s$v zJ8qCNz#EWN`<~9L7s-n0E@TeKN_3;6MLe`rHb`#e?P6A5ygL)iMfM0PI0^O7@*8x= zeeqOUUlJ?`JkcuWKAnGM>7eJBn>fS9Qp5Jd*xkf26ECBV-C@D4A(T4++l^yGg3(lv z&K7DzK7gU6^&cw$jFviC^x-?)Vi*l{%y#cxbNMH>U>-+-J8GgnKrGtdEc)HZ7!$qQ zNEo&DZ$a@B*4&bM;=s~fDlyrhI(?EWe~#Q27+vxnTxE!bf(f@GX-Zjb^%9AF_l;d; zAL;^s=?mvFE}GzTKu;Y-j-Too}JQTl-t0J}3ZA*THe0v?HU?{w{82U$zQ);^M%czp~fV-{)Cv^_wLkiWh zZ~7%V&7u}xi=`Wr4So^Q)7#rSI}Z^sp1m|f_d+j+803({wjp9gZ4#vuAtzmORbZUE z2Y1Zsk#L0Ar z_<0YPH)&+j^r+9vQcu{$#js{5zF(mAK3zeIsE~0&bc32NC#4JKN74>QgFLf?BXkW$ z3;RZko#HF0kZu-_UxoJfZB{aaqY8hBY+3Pj1M*%>eC`H?2Mm=dj% zA$``J$}Zhim*{jcmXep*|0kN3)aUks5Qa^MTDm1!?*Z<*3E!=DI#uEikyP0mYqQa= z;W6QHN0wI)KzI9YatHDNzup?=9$nNkVYP29c>+8HFUNrn!54nams(GcN5)18NRw+% zt{JCnn8*i{UoAj|tiZG7nUJWtcV5a2Cmp92kLptQ{Vwu)!)8Brm0-rsG#aFC6`ZPG zg^%bTh+ii0jo-_qeLPp8ZgeX|*K3&y*MFI&MssLu#rB^I^!UV1zLARRup^%8L^cu- z<|NwHK(TRkEz3_GFO-Tj^0D49iew{z);|p141|nH`cC{q%xZW&NgBF?=nd6IfT=fs2sJkhP^%F~~T;KB6f$3W53w`JsaCt+95#4!(3Co1lTn%D=NPOijlvUMn?k)rmx;N=)%K~!+&`nS}`DsrH=5a0acA_tMU z&NDXnmm4nIajR<`0zfwQOk;!8%o3EvtC99rzM20^MQG4*ZTgBklpcXsdL5hF%?a&J zwP3iVp4|u2LJ!6buRA}kk815TyQsml=~5Vmo-1c4k2zoZJ^WqXsg9Oh0B7*3pNa!8 z;V+Fv`2`lVxRyGRK+i-eXti;wO<)D?s`N)zP#CX~N(ojfz^&Z02+b)cb`qrnG(skP zb7VTXNBPqWejGWl><1#eyYB+$+n|#(UAMZ9$r$zs{q^{<4p1l!n)RagqWIvRqyE_C z63Fk2&4xO;ck`^?CB8RaN@9B=yzFu7m_H~l$imT9$2Mpx-oxMu_VNsE@DiBkKU)M7 zl@adYsZcFwYA7el(vLxbixNAgAA_uJrtfP-`hjYTf`%j=9K;`9R{xoA`KJ-PJcC#k9_LVY++`_3d- z#HBOJfcL5j$P2!(e2Z;}r`F(7)ANA73AH=Z=2ADc$NuBqBgb=KA}`!m<2< zOT)9i1MqRqomm0laK_Oxp|UU7C-yV;G}G}u4~!!GmPc0Hy{g_v7&g-8h2&f`;KkWy zg|ibKn|8#RlWjf52(ttrP6W6l^+mSqiu80#EWNIhc%{8(s)Z*=?DIY2)Sl#s_@M{E zpT&TXOR=EKFVEBS!<}`Jmfgv>XN_tpcxYD_7fPV=s<295|M)BO+Kj~uv7BvpC)cIM z;*+f}Vb#~v>Jqq{kokS|+Q@t38KawUXtL;{kd9(=Z1bnccFG?S_ZFL-vROv%E0bvH zP7Vtf6|%Nk`d8IKyG=(HuuM04&fT5-Uj%CTIwX=_j;sVCF7=$BSqyON(rX7}Z@#=P zW{q!4L@J+`c^kawfK2aWv%5U{w42oRipQn}z*6()x_+2P)dRiZf1#R~5j;R|^*t?5 z2XXgZ;dgreGKla?UhvRYbyljz{*&rSjpN9}i~V#T+l|9fn(a~8ihFO=UYg%gn0|7f zWt6Opi|px=snnICiVFmvZaXe$Qfa0jldh;|k~JhP)4XLHU0c*%GeHIUm_Hoqo(N%u zN(H&HKip6n7^cd2%RR5yVUYLdL z|9T!K+5ddc0Q{p^f4F0Z*R1#2fDeCZgc!ts-Wg8K@Z@!cJ>cK(?)*A&q30g6J<|Hj zPI`0;Z3ty#y>Feh+qOOWej}w``lIS$HR4QTK&t$@r?aZ+8Kn{_m_v7J6y%*fWLFa4 z35htr*X`<9)}1-%ei*~rXyj2RKrqogX>gWNG?x4H;;NBS3pn!ghut!oeBfnSj@8DG zMj8nPskVCh;i=F0SeIqidhDU^mJ+kALhOTnvN;W-AlYjQmEop)^6?VuX513wcRxR< zi0nD`;;nZm?m5a8Bm(VP>pr@O8C)L)wXiL~(g>E~G*!4@=os-2C|Kf{X%#MmPb;>` zBEl-FfPelug|f}SDc&H1h)%9yDcvS}oSu3NL0t&iqh}fB_ysR(DJMh~_m3JxSgk^6 z#XgPSFxakIg`}YLoD_z+A%6uysk7<4se1#Fw#!)hIV9m_rRIhdFcl6nee$ePWAA0` zuneh(Z7>Uy8{vExYFTJ@ti?DD6E%%CHBhQk6tSbhI6duD{N;eHQC&_%sm`)cUF+>& zRA<@G#95|e8NVQ?yj+yaRp>Asr*8S7W{UQ;^dJFGlW{(`M_tZFW%I3aIlfA_#x(J@ z6et^6{DtqW%HJ74-Q=pQ#7{R{g0P5+06*C+q@Z}n+!aHRop z6ag?x%u0&Oy>x8X&Iy~I5aHA_tJE{KkX5&}ahGeX>A`c=&1=mRo0amsmW)EyNhOi; zYm;C;?rde7%lbn~_4YiG1Tcr^cu*r_S|#Jk(Gx&h%|2ks_`o(W2DE2{?@g4Fe$ z+6>6pT&2Pkkq3(a90ISVJN?d1|J7-I=Fro)7J2e;ce9Se`t#5$l{*^M{1-H0U@0%& zm#AhYbRRj*I5h~*bLxoejSgm$Ea%aXN%;|Mb2;?eWEa->&*hSfX74T!79V6LNr}na z-JP0RqP+@R3<-pk*m0A)Ci2{#Ts%hS)}WMJH^TrY#=@*Wq=Y8zV|rjlcdG`kOISO4 zVGX;9DQ;VQO1AwTND0p$Tcfjp9P$xa2oFmb~p{e?Cs2fKSt z29nU94BXR8xt79|34L3~ULuRi?@5`x`sRa&$uCv+3bxO0g20+L2BUh5cRw;7I=#DG zBfaK|wu&w!#2riCXsCUZTaJ2E^YW_47@4U9u9FN_YpO0_!%t7^lURM}UG%DGaR~zk z&_o}?%p&vGmeCRMu6mc@5@;ZW0>o;Nz7FHl`_JdhmiW@o2+*brH5fbSOxAD52aaU` zsD_Q~?gz_PEVcW+>FdZYSI+Gi%#a!U%XMsIFsjnSv-F~$aKNNih235fD5iC_l**f! zux1ixn{1l&_yI&c_DiHr6{XAy+(pe)wF<7^WXlxvzLXd6+1dbqO|8|rdDl2=6r<}m zwUgD{{c;YuaQ_+lX~Q>Zzp`~i_ZLvewCRd`xHWK`E-Ef^da&QXpxC)IT=8c32M8ZS z?sLk1V++$k2J|Pj#V^ngfaRBQmBDmtq|x(_gM2l;Ua4`YMb2Dy$QN7kLpwkCWWIP#n<@n@Rarj8o zOHVJ0h_;J}-NkoBNr40|*+o*Uz!ORL&}|R}v+6qbNzY6vL`#PDt6cz^A7ZH>owvPJ z6;R79{-HN6be&q`7p3c`YqdtR@x3*E`fXJrZ7;sG54Bz`O#1bPHA+JxO_(gUTxLyn zTSfxKzPZ9re{9waAQC{19_D}k^PE2dYyixE99jSP+tb!7pX9=6SuGE9 zG`L8smb%L1vN75u5J?3`PqICr+Tn4){JEP7N2*}YYcavWb!;sCbFsS`5jJPJ!oZ0u zFH+`LFt4I;>I^8?r!Eei!pP%Y@25NO<6cF_=MIZcH6~wG#edY=rm+JN%}{Z_GuR$- zBSA;z`54^>UK)l{vIOHvnL9&QUk6q8M;VQUX@Yx1$s6`8_E0E+ZgvZBN%Hcn>#JDL zd{^m!DB(;6L3H)>QO*|(Br7a>YN5?zS)*=uxDu_PN$u_gQn0sZjq+s#s$~;%6>dd)eHrnW zAxfDsjsJk05^8)K(lXqN?)np=m!XS?t#UiOa=?3+YJV=lRaoq7J+U4L1CL#XabTrc$@(au5WFuVLVI_IEYR;$KQF@(e1$4#N2BvzJX7! zw|38BYLbx|LWA`;mVDZiRBxBceji0uQtI2)e1NvqJxQ!D;9Zio?CI!ox?A;lJ9_ez zQ_%?VL#x)~d3o1Y@R#`G<$2vGu~%V_D(=f-bjI_;Ahsn*y#Hv6$JJxJ)M(4|QS>P> z%~~1(0^p8RmUOzT4gHu;=DrPsu+8XslmQ9d&on|2OEt#7L(>1GDkq?Y4IGEYUQa7> zZ8&u>2+qyH_X;z0))CDA#;QekoRIMw02$qA;Pm0G@GftUs z(KMt6;od@DIp10cgw<#`ZQrDeD~Iz_XCf^NIw$+e7DI;{h%wkF*oKDLAE-^F4yK4Z z>WsiT{y;8WIIv?WR6N!^v@MZ#<1HXp+?V>D9McgQg^b*Di$-3A@4cg>HkpZVj+ECY zuwy(US+tx+u}^HH;C+^p-sqw?qcb;%WhDo&D%J8%({X+|jYQ^d2!>p%kaQmDSx1Q* zEmVgqi-|y{oY5BdJ7Tme#i#^&OTC^$`@;>wIIo};@8c7H3m3$T?F;?JRk_=j_l<`$ zmp71}x#J;TYS^|D3r>$XMqX`ZI4AGFpClmLajYd~k$nDA2OA$`F!Hl_ZG#}pijn%r zq$@5ELf(!0%N}W-(=6*WRnWzgX!$kcO_D{Uk|dxMz<46x0BTt5(bCFraBtf+pd+lc z9Kg67p&}0eOSgY`pvW01q9A|_Z*vz!`_jOO#RwUZcg=$K70r}dhpQb41aScmF}4@kw4@e2R!_!DCId4H>^7!CrIyxfyBN0o+|t?kiOp*w*l#Zof?8atjp?qtFFyYevX&*1mwF}2#y1|~ zmSO-cpsa6*2}(dZ@MWCf`-haJVw$r4X)juh^sl8~Xxic-hFmeUhve$(^(SI`NWYdv z4=4xQ;~>{o9=0reRN%1UipkXIURj}Hu5_F#5y+jXN!b~64d-4(p|Diob9tnjHNqZ72HQS(EO5{ zIm>7BSgw)BEF(hN62$?DE2z@#(Rlva&VZwf+^M$?nlXR+8lN$r{bPNzZPhs3lWq2H zsHoi-e6yLAz2uZ-C0u`%HT~0cI(6 zmRGC!lt7dvtB_d5YNZ7fE?MTJm~D|K{vJK8xi>fG_wHS!DxGf1WXI9a(FlU?ub+1h zJ2Gc0pDa5Q5TsuwCHPhk?Al1g36rEsJ5~{sfgw-6BN@TGfvrjVPFN+PFG%P1|<2A z6*-l_T-R~*8>91B_V84V-me2vfUClNRf3mj8=t=IrUmx3eDfVRA3WcnTlK7*|(CPrFrkd9eTgRwY^_gaWu)%aS-aqwCQn-`Ht)Dbd7`tGE)OPw@I7Cv?9 zl4QtJaEKp`%T3VQp5kZ?P_6gXm%{qaW6oZ9Xx{V1{^5`D({>}+1oBGr=;rzV8b4-s zw$5rs#@2r@=9&{$tvXmxdRK2XgPKM)haPb4%cMR2UylOS^`=aCIN}q4#iUaBu zm+Zae9FrcGyq%KHowF%)vnh?7he88m*ry8ngY>(-SbbZXcRv&CA>@qXTr#3%DBAV_ z6Y!72?hjM4_;!Mw02mMnSOtDidE&=54V7@Is|)JN_}>y|a-_Gi>2W`IoG~eraIA(_ zCIzv&GpTs7S>!7J)I*6tOD*?!l-3Yvi5)&M*WBH&5xu!2YKj~i$CVY;Du}Y zR^rm9gigT6u1w4Xb1xSy0tb?j)IxaGCep|SQwHFw6+8`|e+{%o9v3lU;}4Cj3q2Xk z|LVD7t~ti$xCeXlbsX6CPS&pkEm)|3vekdna-0Cp&aa;Ck6n-&RRz067KG+gO`Jw< z7nLJ$(X=cl@KNA1W?j~{ny0oQ07+DdZ87?wCIZVU?C`-KL&rpd zTewmPc!xahD9w5Kj%%hS8(2;=YNrDd>fSVh$}IGZ_Z>$OM!2jsIO5xCiL}U|5rkKY zwG~!D*<$JK(>t3RoCwWlojA8RB2&GzOohGVnE+zZ=hT#J7f7hHgM&L+en*PUkXJV8 zb@=o7R-r;_Lws^x!V++5V{0H)diQjc_JzvW21pih&}BrP-N^}Uu?Kk?@HAmgTFR5` z78vjXJBCGj=}I{4^0{6zMrdD}`JLH4{@}v;Gv|>_+xHKj@)YSWF{xnD5jv+$oTSD29Ft%z zo$8PK==QC`C++l}px%r)(GO@3c{Sq2KXR+ySa!PaUI*JN1dRWdo_$SWpBPCqX>O72&MMYer&w{;pOgzV#Fbr6`MoLSX?BZD`5!#0?^+DzYSt zQ;WKKppODK9tLB!K^Y*akF9jhn5-bRZ*0{jF<1OSQe)*Czbv7FzbVr=6ov+z4dtbq zm7FEciy`IM;rU&NW2pcQ@#C6k-aa@+NtxGGeS0q>_BKVM-6I$s`OsHc`<+VpcZny{ z+67CX>pI)~`x{K!0Rwrxr9lpw!swsrTtUP_`a3S4KDmNFQYwIQGP^BlY@rM%UysTg zgL}irk8O2a9+7XSjFxgC%^H*PdYwVLi4x*-fE_{-NQoa#`Zv-*KwlM5%A&zQr@ix` z`!+jb<<8Yo!;AJ@XtQEd%iVVKGUpihj3j7vuogn@WRKJe&m(FOD__t~Fk(k09|U(h$KS zYjGK$;`0Z$*hBJ%gZr!HCjS_IpkNpvf6}ji=N-S%um38)k+GHK{tEn^{Q5R>{}j^K zNBs|y^55aVb2i@?vVY3-D~t2L;s55#{vG{0GxF_=`&0BFenbDs^8CAk--&{61j;{! z^ED>>CpzWdHT}N7``3Ojf9>x7K{Nb2{P$&pw@u(b<>9qk{(%3vCH!~r?=j@t%EF(r zLG*9%-`5%buHyG;^ex!@Q_v{?t>Q1C=il+ayY|20RcQW=|I5_-cl_^O<*(iMO#7eq n|27@`9sc{L{nrnnlm7qdh?M0ZU(Esng7BK&!Uu20x2yjG6w8(l literal 0 HcmV?d00001 diff --git a/test/agentchat/contrib/graph_rag/test_neo4j_graph_rag.py b/test/agentchat/contrib/graph_rag/test_neo4j_graph_rag.py index e6013a970a..6b8f73122f 100644 --- a/test/agentchat/contrib/graph_rag/test_neo4j_graph_rag.py +++ b/test/agentchat/contrib/graph_rag/test_neo4j_graph_rag.py @@ -28,18 +28,36 @@ # Test fixture for creating and initializing a query engine @pytest.fixture(scope="module") def neo4j_query_engine(): - input_path = "./test/agentchat/contrib/graph_rag/paul_graham_essay.txt" + input_path = "./test/agentchat/contrib/graph_rag/BUZZ_Employee_Handbook.docx" input_documents = [Document(doctype=DocumentType.TEXT, path_or_url=input_path)] # best practice to use upper-case - entities = Literal["PERSON", "PLACE", "ORGANIZATION"] # - relations = Literal["HAS", "PART_OF", "WORKED_ON", "WORKED_WITH", "WORKED_AT"] + entities = Literal[ + "EMPLOYEE", "EMPLOYER", "POLICY", "BENEFIT", "POSITION", "DEPARTMENT", "CONTRACT", "RESPONSIBILITY" + ] + relations = Literal[ + "FOLLOWS", + "PROVIDES", + "APPLIES_TO", + "DEFINED_AS", + "ASSIGNED_TO", + "PART_OF", + "MANAGES", + "REQUIRES", + "ENTITLED_TO", + "REPORTS_TO", + ] # define which entities can have which relations validation_schema = { - "PERSON": ["HAS", "PART_OF", "WORKED_ON", "WORKED_WITH", "WORKED_AT"], - "PLACE": ["HAS", "PART_OF", "WORKED_AT"], - "ORGANIZATION": ["HAS", "PART_OF", "WORKED_WITH"], + "EMPLOYEE": ["FOLLOWS", "APPLIES_TO", "ASSIGNED_TO", "ENTITLED_TO", "REPORTS_TO"], + "EMPLOYER": ["PROVIDES", "DEFINED_AS", "MANAGES", "REQUIRES"], + "POLICY": ["APPLIES_TO", "DEFINED_AS", "REQUIRES"], + "BENEFIT": ["PROVIDES", "ENTITLED_TO"], + "POSITION": ["DEFINED_AS", "PART_OF", "ASSIGNED_TO"], + "DEPARTMENT": ["PART_OF", "MANAGES", "REQUIRES"], + "CONTRACT": ["PROVIDES", "REQUIRES", "APPLIES_TO"], + "RESPONSIBILITY": ["ASSIGNED_TO", "REQUIRES", "DEFINED_AS"], } # Create Neo4jGraphQueryEngine @@ -48,14 +66,14 @@ def neo4j_query_engine(): password="password", # Change if you reset password host="bolt://172.17.0.3", # Change port=7687, # if needed - database="neo4j", # Change if you want to store the graph in your custom database + database="neo4j", # Change if you want to store the graphh in your custom database entities=entities, # possible entities relations=relations, # possible relations validation_schema=validation_schema, # schema to validate the extracted triplets - strict=True, # enforce the extracted triplets to be in the schema + strict=True, # enofrce the extracted triplets to be in the schema ) - # Initialize the database + # Ingest data and initialize the database query_engine.init_db(input_doc=input_documents) return query_engine @@ -68,14 +86,14 @@ def test_neo4j_query_engine(neo4j_query_engine): """ Test querying functionality of the Neo4j Query Engine. """ - question = "Which companies did Paul Graham work for?" + question = "Which company is the employer?" # Query the database query_result: GraphStoreQueryResult = neo4j_query_engine.query(question=question) print(query_result.answer) - assert query_result.answer.find("Y Combinator") >= 0 + assert query_result.answer.find("BUZZ") >= 0 @pytest.mark.skipif( From 386bc19b3a953a8089584ccbe7629d95f84fcfbd Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Mon, 16 Dec 2024 10:02:34 +0100 Subject: [PATCH 13/70] docstring added to Tool class Signed-off-by: Davor Runje --- autogen/tools/tool.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/autogen/tools/tool.py b/autogen/tools/tool.py index b42c71179b..7fe2905360 100644 --- a/autogen/tools/tool.py +++ b/autogen/tools/tool.py @@ -17,6 +17,13 @@ class Tool: def __init__(self, name: str, description: str, func: Callable[..., Any]) -> None: + """ Create a new Tool object. + + Args: + name (str): The name of the tool. + description (str): The description of the tool. + func (Callable[..., Any]): The function that will be executed when the tool is called. + """ self._name = name self._description = description self._func = func From fb304865f6d58692503aa84ad500ccb7fabc4edc Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Mon, 16 Dec 2024 10:03:59 +0100 Subject: [PATCH 14/70] docstring added to Tool class Signed-off-by: Davor Runje --- autogen/tools/tool.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/autogen/tools/tool.py b/autogen/tools/tool.py index 7fe2905360..b01367235c 100644 --- a/autogen/tools/tool.py +++ b/autogen/tools/tool.py @@ -17,7 +17,7 @@ class Tool: def __init__(self, name: str, description: str, func: Callable[..., Any]) -> None: - """ Create a new Tool object. + """Create a new Tool object. Args: name (str): The name of the tool. From 46227d4bbb12649cf1306cc2b443162f6fe597e4 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Mon, 16 Dec 2024 10:56:21 +0100 Subject: [PATCH 15/70] restrict Python version for using crewai Signed-off-by: Davor Runje --- autogen/interoperability/crewai/__init__.py | 5 +++++ setup.py | 2 +- test/interoperability/crewai/test_crewai.py | 17 ++++++++++++++--- 3 files changed, 20 insertions(+), 4 deletions(-) diff --git a/autogen/interoperability/crewai/__init__.py b/autogen/interoperability/crewai/__init__.py index 63c5268009..f3018b8787 100644 --- a/autogen/interoperability/crewai/__init__.py +++ b/autogen/interoperability/crewai/__init__.py @@ -2,6 +2,11 @@ # # SPDX-License-Identifier: Apache-2.0 +import sys + +if sys.version_info < (3, 10) or sys.version_info >= (3, 13): + raise ImportError("This submodule is only supported for Python versions 3.10, 3.11, and 3.12") + try: import crewai.tools except ImportError: diff --git a/setup.py b/setup.py index 161163b20b..e2eba94b05 100644 --- a/setup.py +++ b/setup.py @@ -122,7 +122,7 @@ "cohere": ["cohere>=5.5.8"], "ollama": ["ollama>=0.3.3", "fix_busted_json>=0.0.18"], "bedrock": ["boto3>=1.34.149"], - "interop-crewai": ["crewai[tools]>=0.86,<1"], + "interop-crewai": ["crewai[tools]>=0.86,<1; python_version>='3.10' and python_version<'3.13'"], "neo4j": neo4j, } diff --git a/test/interoperability/crewai/test_crewai.py b/test/interoperability/crewai/test_crewai.py index 3d26e03d52..6add2012fa 100644 --- a/test/interoperability/crewai/test_crewai.py +++ b/test/interoperability/crewai/test_crewai.py @@ -3,18 +3,29 @@ # SPDX-License-Identifier: Apache-2.0 import os +import sys +import unittest from tempfile import TemporaryDirectory -from typing import Protocol import pytest from conftest import reason, skip_openai -from crewai_tools import FileReadTool + +if sys.version_info >= (3, 10) and sys.version_info < (3, 13): + from crewai_tools import FileReadTool +else: + FileReadTool = unittest.mock.MagicMock() from autogen import AssistantAgent, UserProxyAgent from autogen.interoperability import Interoperable -from autogen.interoperability.crewai import CrewAIInteroperability + +if sys.version_info >= (3, 10) and sys.version_info < (3, 13): + from autogen.interoperability.crewai import CrewAIInteroperability +else: + CrewAIInteroperability = unittest.mock.MagicMock() +# skip if python version is not in [3.10, 3.11, 3.12] +@pytest.mark.skipif(sys.version_info < (3, 10) or sys.version_info >= (3, 13)) class TestCrewAIInteroperability: @pytest.fixture(autouse=True) def setup(self) -> None: From 9de898e23d6e5be1dad8db8005822d7dd11093b7 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Mon, 16 Dec 2024 11:39:02 +0100 Subject: [PATCH 16/70] bug fix Signed-off-by: Davor Runje --- test/test_browser_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_browser_utils.py b/test/test_browser_utils.py index 73fd619940..f0642945ee 100755 --- a/test/test_browser_utils.py +++ b/test/test_browser_utils.py @@ -156,7 +156,7 @@ def test_simple_text_browser(): @pytest.mark.skipif( - skip_bing, + skip_all or skip_bing, reason="do not run bing tests if key is missing", ) def test_bing_search(): From 24444457adf51793982d1ffcb0a0bb86745a139a Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Mon, 16 Dec 2024 11:42:28 +0100 Subject: [PATCH 17/70] CI refactoring Signed-off-by: Davor Runje --- .github/workflows/build.yml | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 02011c464c..a9ef7ea7aa 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -71,14 +71,14 @@ jobs: - name: Install packages and dependencies run: | python -m pip install --upgrade pip wheel - pip install -e .[cosmosdb,interop-crewai] + pip install -e .[test,cosmosdb,interop-crewai] python -c "import autogen" pip install pytest-cov>=5 mock - name: Install optional dependencies for code executors # code executors and udfs auto skip without deps, so only run for python 3.11 if: matrix.python-version == '3.11' run: | - pip install -e ".[jupyter-executor,test]" + pip install -e ".[jupyter-executor]" python -m ipykernel install --user --name python3 - name: Set AUTOGEN_USE_DOCKER based on OS shell: bash @@ -99,11 +99,10 @@ jobs: - name: Coverage with Redis if: matrix.python-version == '3.10' run: | - pip install -e .[test,redis,websockets] + pip install -e .[redis,websockets] pytest test --ignore=test/agentchat/contrib --skip-openai --durations=10 --durations-min=1.0 - name: Test with Cosmos DB run: | - pip install -e .[test,cosmosdb] pytest test/cache/test_cosmos_db_cache.py --skip-openai --durations=10 --durations-min=1.0 - name: Upload coverage to Codecov if: matrix.python-version == '3.10' From c840d2c4d13d17406f7f9428fb178bbe757c412e Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Mon, 16 Dec 2024 11:56:22 +0100 Subject: [PATCH 18/70] Reason added to skipif Signed-off-by: Davor Runje --- test/interoperability/crewai/test_crewai.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/interoperability/crewai/test_crewai.py b/test/interoperability/crewai/test_crewai.py index 6add2012fa..f563116a83 100644 --- a/test/interoperability/crewai/test_crewai.py +++ b/test/interoperability/crewai/test_crewai.py @@ -25,7 +25,9 @@ # skip if python version is not in [3.10, 3.11, 3.12] -@pytest.mark.skipif(sys.version_info < (3, 10) or sys.version_info >= (3, 13)) +@pytest.mark.skipif( + sys.version_info < (3, 10) or sys.version_info >= (3, 13), reason="Only Python 3.10, 3.11, 3.12 are supported" +) class TestCrewAIInteroperability: @pytest.fixture(autouse=True) def setup(self) -> None: From 2c4e561412a8e671bb7e291ef7ce1730a28a3c88 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Mon, 16 Dec 2024 12:08:00 +0100 Subject: [PATCH 19/70] import jupyter_kernel_gateway added to embedded ipyhon code executor Signed-off-by: Davor Runje --- autogen/coding/jupyter/embedded_ipython_code_executor.py | 1 + 1 file changed, 1 insertion(+) diff --git a/autogen/coding/jupyter/embedded_ipython_code_executor.py b/autogen/coding/jupyter/embedded_ipython_code_executor.py index 09e4a06043..f38e06a0b4 100644 --- a/autogen/coding/jupyter/embedded_ipython_code_executor.py +++ b/autogen/coding/jupyter/embedded_ipython_code_executor.py @@ -13,6 +13,7 @@ from queue import Empty from typing import Any, ClassVar, List +import jupyter_kernel_gateway from jupyter_client import KernelManager # type: ignore[attr-defined] from jupyter_client.kernelspec import KernelSpecManager from pydantic import BaseModel, Field, field_validator From 63f3949640a9d0a3f37e669f5c18187b523f905e Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Mon, 16 Dec 2024 12:22:19 +0100 Subject: [PATCH 20/70] add interop-crewai target in CI for openai tests Signed-off-by: Davor Runje --- .github/workflows/openai.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/openai.yml b/.github/workflows/openai.yml index 7dcf3175ba..51417d5f6e 100644 --- a/.github/workflows/openai.yml +++ b/.github/workflows/openai.yml @@ -55,7 +55,7 @@ jobs: if: matrix.python-version == '3.9' run: | pip install docker - pip install -e .[redis] + pip install -e .[redis,interop-crewai] - name: Coverage if: matrix.python-version == '3.9' env: From 63e311c25511be2be1df7703a6ea6150f9a71f35 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Mon, 16 Dec 2024 15:07:48 +0100 Subject: [PATCH 21/70] Initial LangchainInteroperability implementation --- .../interoperability/langchain/__init__.py | 14 + .../interoperability/langchain/langchain.py | 30 + notebook/autobuild_agent_library.ipynb | 1855 +++++++++-------- notebook/tools_crewai_tools_integration.ipynb | 2 +- .../tools_langchain_tools_integration.ipynb | 152 ++ setup.py | 1 + test/interoperability/crewai/test_crewai.py | 2 +- test/interoperability/langchain/__init__.py | 3 + .../langchain/test_langchain.py | 71 + 9 files changed, 1201 insertions(+), 929 deletions(-) create mode 100644 autogen/interoperability/langchain/__init__.py create mode 100644 autogen/interoperability/langchain/langchain.py create mode 100644 notebook/tools_langchain_tools_integration.ipynb create mode 100644 test/interoperability/langchain/__init__.py create mode 100644 test/interoperability/langchain/test_langchain.py diff --git a/autogen/interoperability/langchain/__init__.py b/autogen/interoperability/langchain/__init__.py new file mode 100644 index 0000000000..bdae155fdd --- /dev/null +++ b/autogen/interoperability/langchain/__init__.py @@ -0,0 +1,14 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +try: + import langchain.tools +except ImportError: + raise ImportError( + "Please install `interop-langchain` extra to use this module:\n\n\tpip install ag2[interop-langchain]" + ) + +from .langchain import LangchainInteroperability + +__all__ = ["LangchainInteroperability"] diff --git a/autogen/interoperability/langchain/langchain.py b/autogen/interoperability/langchain/langchain.py new file mode 100644 index 0000000000..d8e3590612 --- /dev/null +++ b/autogen/interoperability/langchain/langchain.py @@ -0,0 +1,30 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +from typing import Any + +from langchain_core.tools import BaseTool as LangchainTool + +from ...tools import Tool +from ..interoperability import Interoperable + +__all__ = ["LangchainInteroperability"] + + +class LangchainInteroperability(Interoperable): + def convert_tool(self, tool: Any) -> Tool: + if not isinstance(tool, LangchainTool): + raise ValueError(f"Expected an instance of `crewai.tools.BaseTool`, got {type(tool)}") + + # needed for type checking + langchain_tool: LangchainTool = tool # type: ignore[no-any-unimported] + + def func(tool_input: langchain_tool.args_schema) -> Any: # type: ignore[no-any-unimported] + return langchain_tool.run(tool_input.model_dump()) + + return Tool( + name=langchain_tool.name, + description=langchain_tool.description, + func=func, + ) diff --git a/notebook/autobuild_agent_library.ipynb b/notebook/autobuild_agent_library.ipynb index 02fcbffc2c..2c2010c3f4 100644 --- a/notebook/autobuild_agent_library.ipynb +++ b/notebook/autobuild_agent_library.ipynb @@ -1,932 +1,933 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "6264276d39875995", - "metadata": { - "collapsed": false - }, - "source": [ - "# Automatically Build Multi-agent System from Agent Library\n", - "\n", - "By: [Linxin Song](https://linxins97.github.io/), [Jieyu Zhang](https://jieyuz2.github.io/)\n", - "\n", - "In this notebook, we introduce a new feature for AutoBuild, `build_from_library`, which help users build an automatic task-solving process powered by a multi-agent system from a pre-defined agent library. \n", - "Specifically, in `build_from_library`, we prompt an LLM to explore useful agents from a pre-defined agent library, generating configurations for those agents for a group chat to solve the user's task." - ] - }, - { - "cell_type": "markdown", - "id": "ec78dda8e3826d8a", - "metadata": { - "collapsed": false - }, - "source": [ - "## Requirement\n", - "\n", - "AutoBuild require `autogen[autobuild]`, which can be installed by the following command:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "e8e9ae50658be975", - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "%pip install autogen[autobuild]" - ] - }, - { - "cell_type": "markdown", - "id": "176c200804af63f3", - "metadata": { - "collapsed": false - }, - "source": [ - "## Preparation and useful tools\n", - "We need to specify a `config_path`, `default_llm_config` that include backbone LLM configurations." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "2505f029423b21ab", - "metadata": { - "ExecuteTime": { - "end_time": "2023-12-26T16:58:02.762702600Z", - "start_time": "2023-12-26T16:58:02.472073Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "import json\n", - "\n", - "import autogen\n", - "from autogen.agentchat.contrib.agent_builder import AgentBuilder\n", - "\n", - "config_file_or_env = \"OAI_CONFIG_LIST\" # modify path\n", - "llm_config = {\"temperature\": 0}\n", - "config_list = autogen.config_list_from_json(config_file_or_env, filter_dict={\"model\": [\"gpt-4-1106-preview\", \"gpt-4\"]})\n", - "\n", - "def start_task(execution_task: str, agent_list: list):\n", - " group_chat = autogen.GroupChat(agents=agent_list, messages=[], max_round=12)\n", - " manager = autogen.GroupChatManager(groupchat=group_chat, llm_config={\"config_list\": config_list, **llm_config})\n", - " agent_list[0].initiate_chat(manager, message=execution_task)" - ] - }, - { - "cell_type": "markdown", - "id": "5fb3db8885dd6ee6", - "metadata": { - "collapsed": false - }, - "source": [ - "## Example for generating an agent library\n", - "Here, we show an example of generating an agent library from a pre-defined list of agents' names by prompting a `gpt-4`. You can also prepare a handcrafted library yourself.\n", - "\n", - "A Library contains each agent's name, description and system_message. The description is a brief introduction about agent's characteristics. As we will feed all agents' names and description to gpt-4 and let it choose the best agents for us, each agent's description should be simple but informative. \n", - "\n", - "First, we define a prompt template for description and system_message generation and a list of agents' name:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "68315f6ec912c58a", - "metadata": { - "ExecuteTime": { - "end_time": "2023-12-23T07:39:03.317527600Z", - "start_time": "2023-12-23T07:39:03.276859600Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "AGENT_SYS_MSG_PROMPT = \"\"\"Acccording to the following postion name, write a high quality instruction for the position following a given example. You should only return the instruction.\n", - "\n", - "# Position Name\n", - "{position}\n", - "\n", - "# Example instruction for Data Analyst\n", - "\n", - "As Data Analyst, you are tasked with leveraging your extensive knowledge in data analysis to recognize and extract meaningful features from vast datasets. Your expertise in machine learning, specifically with the Random Forest Classifier, allows you to construct robust predictive models adept at handling both classification and regression tasks. You excel in model evaluation and interpretation, ensuring that the performance of your algorithms is not just assessed with precision, but also understood in the context of the data and the problem at hand. With a command over Python and proficiency in using the pandas library, you manipulate and preprocess data with ease.\n", - "\"\"\"\n", - "\n", - "AGENT_DESC_PROMPT = \"\"\"According to position name and the instruction, summarize the position into a high quality one sentence description.\n", - "\n", - "# Position Name\n", - "{position}\n", - "\n", - "# Instruction\n", - "{instruction}\n", - "\"\"\"\n", - "\n", - "position_list = [\n", - " \"Environmental_Scientist\",\n", - " \"Astronomer\",\n", - " \"Software_Developer\",\n", - " \"Data_Analyst\",\n", - " \"Journalist\",\n", - " \"Teacher\",\n", - " \"Lawyer\",\n", - " \"Programmer\",\n", - " \"Accountant\",\n", - " \"Mathematician\",\n", - " \"Physicist\",\n", - " \"Biologist\",\n", - " \"Chemist\",\n", - " \"Statistician\",\n", - " \"IT_Specialist\",\n", - " \"Cybersecurity_Expert\",\n", - " \"Artificial_Intelligence_Engineer\",\n", - " \"Financial_Analyst\",\n", - "]" - ] - }, - { - "cell_type": "markdown", - "id": "72b8e7d9d334a5c2", - "metadata": { - "collapsed": false - }, - "source": [ - "Then we can prompt a `gpt-4` model to generate each agent's system message as well as the description:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "8fbfef9268fc5191", - "metadata": { - "ExecuteTime": { - "end_time": "2023-12-23T07:40:01.703372Z", - "start_time": "2023-12-23T07:39:04.472589200Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "build_manager = autogen.OpenAIWrapper(config_list=config_list)\n", - "sys_msg_list = []\n", - "\n", - "for pos in position_list:\n", - " resp_agent_sys_msg = (\n", - " build_manager.create(\n", - " messages=[\n", - " {\n", - " \"role\": \"user\",\n", - " \"content\": AGENT_SYS_MSG_PROMPT.format(\n", - " position=pos,\n", - " ),\n", - " }\n", - " ]\n", - " )\n", - " .choices[0]\n", - " .message.content\n", - " )\n", - " resp_desc_msg = (\n", - " build_manager.create(\n", - " messages=[\n", - " {\n", - " \"role\": \"user\",\n", - " \"content\": AGENT_DESC_PROMPT.format(\n", - " position=pos,\n", - " instruction=resp_agent_sys_msg,\n", - " ),\n", - " }\n", - " ]\n", - " )\n", - " .choices[0]\n", - " .message.content\n", - " )\n", - " sys_msg_list.append({\"name\": pos, \"system_message\": resp_agent_sys_msg, \"description\": resp_desc_msg})" - ] - }, - { - "cell_type": "markdown", - "id": "9e26c6db4befacc5", - "metadata": { - "collapsed": false - }, - "source": [ - "The generated profile will have the following format:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "8ede1d7088eb183d", - "metadata": { - "ExecuteTime": { - "end_time": "2023-12-23T07:40:01.712399300Z", - "start_time": "2023-12-23T07:40:01.707400200Z" - }, - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'name': 'Environmental_Scientist',\n", - " 'system_message': 'As an Environmental Scientist, you are responsible for applying your profound knowledge of environmental science to analyze ecological data and assess the impact of human activities on natural resources and ecosystems. Your proficiency in environmental assessment techniques enables you to design and conduct field studies, collect samples, and monitor environmental parameters effectively. Utilizing Geographic Information Systems (GIS), you spatially analyze and visualize environmental data to better understand patterns and changes in the landscape. You are adept at interpreting the results and communicating your findings clearly to stakeholders, policymakers, and the public, thereby contributing to informed decision-making on environmental issues. Your role is essential in developing sustainable practices and recommending mitigation measures to minimize environmental degradation and promote conservation.',\n", - " 'description': 'As an Environmental Scientist, you are tasked with analyzing and assessing the impact of human activities on ecosystems by conducting field studies, using GIS for spatial analysis, and communicating your findings to inform sustainable practices and conservation efforts.'},\n", - " {'name': 'Astronomer',\n", - " 'system_message': 'As an Astronomer, your duty involves diligent observation and analysis of celestial phenomena across the universe. Utilize cutting-edge telescopes and instruments to gather astronomical data, looking for patterns and irregularities that can lead to groundbreaking discoveries. Your profound knowledge in astrophysics is pivotal in interpreting these findings, which may include identifying new celestial objects, scrutinizing the properties and behaviors of stars, planets, and galaxies, and understanding cosmic events. Mastery of complex astronomical software and advanced mathematics is crucial for modeling astronomical phenomena and processing the vast amounts of data. Your role is essential in advancing our understanding of the cosmos, contributing to the broader scientific community by publishing your findings in reputable journals and engaging in peer collaboration to further space exploration and research.',\n", - " 'description': 'An Astronomer is a professional who meticulously observes, analyzes, and interprets celestial phenomena using advanced telescopes and instruments, requiring a deep knowledge of astrophysics, proficiency in mathematical modeling, and collaboration in scientific communities to enhance our comprehension of the universe.'},\n", - " {'name': 'Software_Developer',\n", - " 'system_message': 'As a Software Developer, your objective is to craft, test, and maintain the software that will meet the needs of our users and clients. Your proficiency in programming languages such as Java, C#, or JavaScript is essential, enabling you to write clean, efficient, and maintainable code. You will design algorithms and flowcharts to create systems that are logical and user-friendly. Collaboration with cross-functional teams, including product managers and designers, is crucial in order to understand software requirements and deliver innovative solutions. With your understanding of the software development life cycle, you will work through the processes of coding, debugging, testing, and deployment. You will employ industry best practices such as version control with Git and conduct code reviews to maintain high standards of software quality. Your role places you at the heart of our development efforts, where your technical prowess advances the functionality, scalability, and reliability of our software products.',\n", - " 'description': 'A Software Developer is responsible for designing, coding, testing, and maintaining software that meets client needs using languages like Java, C#, or JavaScript, collaborating with teams, adhering to best practices like Git for version control, and ensuring quality and innovation throughout the development life cycle.'},\n", - " {'name': 'Data_Analyst',\n", - " 'system_message': 'As a Data Analyst, your role is pivotal in interpreting complex data and providing insights that inform strategic decision-making. Utilize your analytical skills to cleanse and organize large sets of structured and unstructured data, ensuring its accuracy and readiness for in-depth analysis. Apply statistical analysis and predictive modeling to uncover trends, patterns, and correlations that drive operational improvements and innovative solutions. Use your proficiency in SQL for database interactions, and harness visualization tools such as Tableau or Power BI to craft compelling stories from data, aiding stakeholders in visualizing the implications of your findings. Stay abreast with the latest analytics techniques and continuously refine your models for enhanced performance, contributing significantly to the data-driven culture of our organization.',\n", - " 'description': 'The Data Analyst interprets complex datasets to provide strategic insights, cleanses and organizes data, performs statistical analysis and predictive modeling to identify trends and inform improvements, utilizes SQL for database management, and employs visualization tools like Tableau or Power BI to effectively communicate findings to stakeholders.'},\n", - " {'name': 'Journalist',\n", - " 'system_message': 'As a Journalist, you are responsible for identifying and pursuing newsworthy stories with the utmost ethical standards and a commitment to factual reporting. Your innate curiosity and excellent communication skills enable you to conduct thorough research and interviews, uncovering the details that make each story compelling and informative. Skilled in both written and verbal storytelling, you craft articles, reports, and features that engage and inform the public, adhering to strict deadlines without compromising on the integrity and accuracy of your work. Proficient in multimedia journalism, you adeptly use digital tools and social media to reach a wider audience, ensuring that your stories have the maximum impact.',\n", - " 'description': 'A Journalist is tasked with ethically sourcing and meticulously reporting newsworthy events, utilizing strong research and storytelling abilities across multiple platforms to accurately inform and engage a diverse audience.'},\n", - " {'name': 'Teacher',\n", - " 'system_message': 'As a Teacher, you are entrusted with the essential responsibility of fostering knowledge and encouraging academic and personal growth in your students. Your deep understanding of pedagogy, coupled with your expertise in the subject matter, enables you to create and deliver curricula that are both engaging and educational. Your adeptness at differentiated instruction allows you to tailor your teaching methods to suit the varied learning styles and needs within your classroom. By skillfully blending traditional teaching techniques with modern educational technology, you facilitate a dynamic and interactive learning environment. You excel in assessment and feedback, not only to gauge student progress but also to continuously improve your own teaching strategies. With strong interpersonal skills, you maintain open lines of communication with students, parents, and colleagues, fostering a collaborative and supportive school community.',\n", - " 'description': \"A Teacher is responsible for cultivating students' knowledge and growth through expertise in pedagogical practices and subject matter, designing engaging curricula, adapting teaching methods to diverse learning needs, integrating technology, and using assessment for continuous improvement while nurturing a cooperative school community.\"},\n", - " {'name': 'Lawyer',\n", - " 'system_message': 'As a Lawyer, you are required to uphold the highest standards of legal proficiency and ethical practice. Your role involves advising clients on their legal rights and responsibilities, as well as representing them in civil and criminal proceedings. You must possess a strong understanding of the law, paired with the ability to analyze case law and legislate history, to construct compelling arguments in support of your client’s position. Your keen attention to detail and dedication to thorough research are crucial in identifying legal precedents and crafting legal documents that adhere to the strictest of procedural standards. Moreover, you must exhibit exceptional negotiation skills to achieve favorable outcomes, whether in the courtroom or at the settlement table. With your articulate verbal and written communication, you clearly and persuasively present cases, explaining complex legal concepts in understandable terms to clients, judges, and juries. Your commitment to confidentiality and upholding justice is paramount and reflected in all aspects of your professional conduct.',\n", - " 'description': 'A Lawyer is a professionally trained legal advocate responsible for representing clients in legal proceedings, providing expert advice on legal matters, constructing persuasive arguments through meticulous research and analysis of law, and negotiating settlements, all while adhering to the highest ethical standards and maintaining strict confidentiality.'},\n", - " {'name': 'Programmer',\n", - " 'system_message': 'As a Programmer, you are responsible for the design, development, and implementation of software programs. Utilize your comprehensive understanding of programming languages, including but not limited to Java, C++, and Python, to create efficient and innovative software solutions. Your role involves writing clean, maintainable code while adhering to best practices in software development. You are expected to troubleshoot, debug, and upgrade existing software, as well as collaborate with cross-functional teams to define and design new product features. Your ability to think algorithmically and solve problems systematically will be integral in creating software that is not only functional but also scalable and secure.',\n", - " 'description': 'A Programmer designs, develops, and implements innovative and efficient software solutions using languages like Java, C++, and Python, ensuring code maintainability, collaborating on new features, and enhancing existing applications with a strong focus on scalability and security.'},\n", - " {'name': 'Accountant',\n", - " 'system_message': 'As Accountant, you are charged with the meticulous management and analysis of financial records, ensuring accuracy and compliance with relevant laws and regulations. Utilize your comprehensive understanding of accounting principles to prepare, examine, and maintain financial reports and statements, including balance sheets and income statements. Your role involves the reconciliation of accounts, evaluating financial operations to recommend best practices, identifying issues, and strategizing solutions for fiscal efficiency and profitability. Mastery in accounting software such as QuickBooks or Sage, alongside proficiency in Microsoft Excel, enables you to efficiently process and analyze financial data. You must ensure proper financial documentation and control systems are in place, providing comprehensive support to the organization’s financial health and integrity.',\n", - " 'description': 'As an Accountant, you are responsible for the accurate and compliant management, analysis, and reporting of financial data, along with recommending strategies to enhance fiscal efficiency and profitability, supported by proficiency in accounting software and Microsoft Excel.'},\n", - " {'name': 'Mathematician',\n", - " 'system_message': 'As a Mathematician, you are responsible for utilizing your profound understanding of mathematical theories and methodologies to solve complex theoretical and practical problems across various domains. Your proficiency in abstract reasoning enables you to develop new mathematical principles and to recognize and articulate the underlying mathematical relationships within real-world scenarios. You apply your expertise in calculus, algebra, statistics, and other mathematical branches to conduct rigorous analyses and to model systems for prediction and optimization. With a strong foundation in logic and quantitative reasoning, you perform peer reviews and contribute to interdisciplinary research projects, ensuring accuracy and consistency in mathematical arguments and results. Your role is crucial in advancing mathematical knowledge and providing innovative solutions to scientific and engineering challenges.',\n", - " 'description': 'As a Mathematician, you apply advanced mathematical theories and analytical skills to solve theoretical and practical problems in various industries, develop new principles, and provide innovative solutions to complex scientific and engineering challenges.'},\n", - " {'name': 'Physicist',\n", - " 'system_message': 'As a Physicist, you are charged with applying your profound understanding of the physical laws that govern the universe to unravel complex scientific phenomena. Your proficiency in theoretical and experimental physics enables you to develop models and conduct experiments that explore fundamental forces and particles. With exceptional analytical skills, you interpret empirical data to validate existing theories or propose new explanations for unexplained observations. Mastery in the use of mathematical tools such as differential equations and linear algebra is crucial for you to simulate physical processes. You are also adept at using specialized software and equipment for data acquisition and analysis, contributing to advancements in fields ranging from quantum mechanics to cosmology. Your strong critical thinking abilities empower you to solve intricate problems, and your commitment to scientific rigor ensures the integrity and accuracy of your research outcomes.',\n", - " 'description': 'A Physicist applies deep knowledge of physical laws to investigate scientific phenomena through theoretical modeling and experimental research, utilizing advanced mathematical techniques and specialized equipment to advance understanding in areas such as quantum mechanics and cosmology.'},\n", - " {'name': 'Biologist',\n", - " 'system_message': 'As a Biologist, you are entrusted with the study and understanding of living organisms, applying your expertise to investigate their functions, genetics, evolution, and ecosystems. Your skills in experimental design empower you to conduct research and experiments that can unlock new biological insights and improve our comprehension of life processes. Utilizing advanced microscopy techniques and molecular biology methods, you should meticulously analyze cell structures and DNA sequences to uncover the intricacies of life at a microscopic level. Demonstrate proficiency in bioinformatics tools to analyze genetic data and contribute valuable findings to the scientific community. Furthermore, as a communicator of science, ensure that your research findings are effectively documented and presented in scientific journals and at conferences, thereby enhancing the collective knowledge in your field.',\n", - " 'description': 'A Biologist meticulously studies and understands living organisms, conducting advanced research to decode genetics and ecosystems and sharing findings through scientific publications and presentations.'},\n", - " {'name': 'Chemist',\n", - " 'system_message': 'As a Chemist, you are charged with applying your profound understanding of chemical principles to conduct complex experiments, synthesize new compounds, and analyze the molecular and atomic structure of materials. Your proficiency in utilizing sophisticated analytical techniques - such as chromatography, spectroscopy, and mass spectrometry - enables you to decipher the composition and properties of substances. The knowledge you hold in chemical safety and handling procedures ensures a secure laboratory environment. With an adeptness in maintaining accurate records and an insightful approach to interpreting data, you transform raw experimental results into valuable scientific insights. Your ability to communicate complex chemical information clearly makes you essential in collaborative research efforts and in driving innovation within the field.',\n", - " 'description': 'As a Chemist, you are responsible for conducting advanced experiments, synthesizing compounds, deciphering substance compositions with techniques like chromatography and mass spectrometry, and transforming experimental data into scientific insights, while maintaining safety and clear communication in research collaborations.'},\n", - " {'name': 'Statistician',\n", - " 'system_message': 'As a Statistician, your primary duty is to apply mathematical and statistical methods to collect, analyze, and interpret numerical data to make informed decisions. Your strong grounding in probability theory will be essential for designing surveys and experiments to generate data. You are adept at constructing and applying sophisticated statistical models and methods, such as linear regression, ANOVA, or time-series analysis, ensuring that you accurately capture trends and relationships within the data. You possess an in-depth understanding of statistical software such as R or SAS, allowing you to perform complex analyses with efficiency and precision. Your ability to communicate complex statistical concepts to non-experts will be crucial; hence, your role includes presenting findings in a clear, actionable manner, with data visualizations and reports that drive strategic planning and policy development.',\n", - " 'description': 'A Statistician employs and interprets advanced statistical techniques to design data-collection processes, analyze data, and present findings in a comprehensible manner, supporting evidence-based decision-making and policy formation.'},\n", - " {'name': 'IT_Specialist',\n", - " 'system_message': 'As an IT Specialist, your primary responsibility is to maintain the integrity and functionality of all our computer systems and networks. Your comprehensive understanding of hardware and software is crucial for diagnosing and resolving technical issues. You are adept at implementing network security measures to protect data and systems from cyber threats. You also play a significant role in systems and software upgrades, ensuring a seamless transition without disrupting workflow. Utilizing your strong problem-solving skills and proficiency in scripting languages, you automate repetitive tasks, enhancing system efficiency. Your ability to communicate effectively with team members and non-technical staff allows you to provide clear guidance and end-user support.',\n", - " 'description': 'An IT Specialist is responsible for upholding and optimizing our computer systems and networks through maintenance, security, upgrades, issue resolution, automation, and providing support and clear communication to both technical and non-technical personnel.'},\n", - " {'name': 'Cybersecurity_Expert',\n", - " 'system_message': \"As a Cybersecurity Expert, you are charged with the responsibility of safeguarding the organization's computer networks and systems. Your deep understanding of cyber threats and mitigation techniques is critical in identifying vulnerabilities and protecting against malicious attacks. Employing your experience with tools such as firewalls, antivirus software, and intrusion detection systems, you will continuously monitor and defend our digital infrastructure. You are expected to conduct regular security audits and penetration testing to simulate cyber attacks and find potential weaknesses before they can be exploited. Your proficiency in risk management frameworks and incident response protocols ensures that you are prepared to swiftly handle and mitigate any security incidents that occur. With your expertise in encryption technologies and network protocols, you protect sensitive data and ensure compliance with relevant security standards and regulations. Your foresight in staying up-to-date with the latest cybersecurity trends and threats is paramount to maintaining the organization's digital defense at its peak.\",\n", - " 'description': \"As a Cybersecurity Expert, you are responsible for the proactive protection and defense of an organization's computer networks and systems against cyber threats through continuous monitoring, conducting security audits, penetrating testing, and swiftly mitigating security incidents, while ensuring compliance with security regulations.\"},\n", - " {'name': 'Artificial_Intelligence_Engineer',\n", - " 'system_message': 'As an Artificial Intelligence Engineer, you are responsible for conceptualizing, designing, and implementing intelligent systems that simulate human cognitive processes. Your role demands a deep understanding of neural networks, particularly Convolutional Neural Networks (CNNs) for image recognition tasks and Recurrent Neural Networks (RNNs) for natural language processing. With your expertise in TensorFlow or PyTorch, you develop complex models that can learn, adapt, and make decisions. You prioritize the ethical design and deployment of AI systems, conscious of the implications your work may have on society. Mastery of algorithms and a proficiency in a high-level programming language, preferably Python, enable you to transform theoretical AI concepts into practical solutions that drive innovation and efficiency.',\n", - " 'description': 'An Artificial Intelligence Engineer specializes in creating and implementing advanced intelligent systems, with a mastery of neural networks, machine learning frameworks, and ethical AI principles, to develop innovative solutions that emulate human cognition.'},\n", - " {'name': 'Financial_Analyst',\n", - " 'system_message': 'As a Financial Analyst, you are entrusted with utilizing your in-depth understanding of financial principles to assess investment opportunities, analyze financial data, and forecast economic trends. Your proficiency in financial modeling is paramount, enabling you to develop complex models that underpin the valuation of stocks, bonds, and other financial instruments. With a sharp eye for detail, you scrutinize company financial statements to derive actionable insights and recommend strategies to optimize financial performance. Your expertise in Excel, especially with advanced functions and formulas, allows you to efficiently manipulate and analyze large financial datasets. You are a whiz at creating compelling visualizations and delivering presentations to communicate your findings and influence strategic decisions. Your role is crucial in guiding investment decisions and driving the fiscal prudence of the organization.',\n", - " 'description': \"A Financial Analyst performs in-depth financial analysis and modeling to evaluate investments, forecast economic trends, and deliver strategic recommendations, leveraging advanced Excel skills to inform and guide the organization's financial decisions.\"}]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sys_msg_list" - ] - }, - { - "cell_type": "markdown", - "id": "256dd32b03a7a172", - "metadata": { - "collapsed": false - }, - "source": [ - "We can save the generated agents' information into a json file." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "53111125938845cf", - "metadata": { - "ExecuteTime": { - "end_time": "2023-12-23T07:40:01.750855900Z", - "start_time": "2023-12-23T07:40:01.710399600Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "json.dump(sys_msg_list, open(\"./agent_library_example.json\", \"w\"), indent=4)" - ] - }, - { - "cell_type": "markdown", - "id": "cfd883b79a3bd932", - "metadata": { - "collapsed": false - }, - "source": [ - "## Build agents from library (by LLM)\n", - "Here, we introduce how to build agents from the generated library. As in the previous `build`, we also need to specify a `building_task` that lets the build manager know which agents should be selected from the library according to the task. \n", - "\n", - "We also need to specify a `library_path_or_json`, which can be a path of library or a JSON string with agents' configs. Here, we use the previously saved path as the library path." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "8963a8709c8e92e2", - "metadata": { - "ExecuteTime": { - "end_time": "2023-12-23T07:40:01.752918500Z", - "start_time": "2023-12-23T07:40:01.735461Z" - }, - "collapsed": false - }, - "outputs": [], - "source": [ - "library_path_or_json = \"./agent_library_example.json\"\n", - "building_task = \"Find a paper on arxiv by programming, and analyze its application in some domain. For example, find a recent paper about gpt-4 on arxiv and find its potential applications in software.\"" - ] - }, - { - "cell_type": "markdown", - "id": "72656a8d0c1a9b12", - "metadata": { - "collapsed": false - }, - "source": [ - "Then, we can call the `build_from_library` from the AgentBuilder to generate a list of agents from the library and let them complete the user's `execution_task` in a group chat." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "5c669b76b2c9b750", - "metadata": { - "ExecuteTime": { - "end_time": "2023-12-23T07:46:02.075542200Z", - "start_time": "2023-12-23T07:43:55.489042900Z" - }, - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[32m==> Looking for suitable agents in the library...\u001b[0m\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Programmer', 'Mathematician'] are selected.\n", - "\u001b[32m==> Creating agents...\u001b[0m\n", - "Creating agent Programmer...\n", - "Creating agent Mathematician...\n", - "Adding user console proxy...\n", - "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", - "\n", - "Find a recent paper about explainable AI on arxiv and find its potential applications in medical.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Computer_terminal\n", - "\u001b[0m\n", - "\u001b[33mComputer_terminal\u001b[0m (to chat_manager):\n", - "\n", - "There is no code from the last 1 message for me to execute. Group chat manager should let other participants to continue the conversation. If the group chat manager want to end the conversation, you should let other participant reply me only with \"TERMINATE\"\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Programmer\n", - "\u001b[0m\n", - "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", - "\n", - "To find a recent paper about explainable AI on arXiv, we can use the arXiv API to search for papers that match the query. However, since I cannot directly access external APIs, I suggest that one of us manually searches for the paper on the arXiv website using relevant search terms such as \"explainable AI\" and \"medical applications\". Once we find a suitable paper, we can discuss its potential applications in the medical field. \n", - "\n", - "Mathematician, would you like to perform the search, or shall I provide a Python script that could be used to perform the search programmatically?\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Mathematician\n", - "\u001b[0m\n", - "\u001b[33mMathematician\u001b[0m (to chat_manager):\n", - "\n", - "As a Mathematician, I can certainly appreciate the value of a programmatic approach to searching for academic papers. However, since I do not have direct access to execute code or APIs, I would suggest that you, as the Programmer, provide the Python script that could be used to perform the search on arXiv. Once we have identified a paper, I can then assist in discussing its potential applications in the medical field from a mathematical perspective.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Programmer\n", - "\u001b[0m\n", - "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", - "\n", - "Understood. I will provide a Python script that can be used to search for recent papers about explainable AI on arXiv with potential applications in the medical field. The script will use the `arxiv` Python package, which is a wrapper for the arXiv API. If the package is not installed, we will need to install it first.\n", - "\n", - "Let's start by checking if the `arxiv` package is installed and if not, we will install it. Computer_terminal, please execute the following command to check for the `arxiv` package and install it if necessary.\n", - "\n", - "```sh\n", - "pip show arxiv || pip install arxiv\n", - "```\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Computer_terminal\n", - "\u001b[0m\n", - "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is sh)...\u001b[0m\n", - "\u001b[33mComputer_terminal\u001b[0m (to chat_manager):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "Name: arxiv\n", - "Version: 2.1.0\n", - "Summary: Python wrapper for the arXiv API: https://arxiv.org/help/api/\n", - "Home-page: https://github.com/lukasschwab/arxiv.py\n", - "Author: Lukas Schwab\n", - "Author-email: lukas.schwab@gmail.com\n", - "License: MIT\n", - "Location: /home/vscode/.local/lib/python3.10/site-packages\n", - "Requires: feedparser, requests\n", - "Required-by: \n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Programmer\n", - "\u001b[0m\n", - "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", - "\n", - "Great, the `arxiv` package is already installed. Now, I will provide a Python script that uses the `arxiv` package to search for recent papers related to explainable AI with potential applications in the medical field. The script will query the arXiv API for papers with relevant keywords and print out the title and summary of the most recent paper found.\n", - "\n", - "Computer_terminal, please execute the following Python script.\n", - "\n", - "```python\n", - "import arxiv\n", - "\n", - "# Define the search query\n", - "search_query = 'all:explainable AI AND all:medical'\n", - "\n", - "# Search for papers on arXiv\n", - "search = arxiv.Search(\n", - " query = search_query,\n", - " max_results = 1,\n", - " sort_by = arxiv.SortCriterion.SubmittedDate\n", - ")\n", - "\n", - "# Fetch the most recent paper\n", - "for paper in search.results():\n", - " print(\"Title:\", paper.title)\n", - " print(\"Summary:\", paper.summary)\n", - " # Only print the most recent paper\n", - " break\n", - "```\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Computer_terminal\n", - "\u001b[0m\n", - "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", - "\u001b[33mComputer_terminal\u001b[0m (to chat_manager):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "Title: Automated Information Extraction from Thyroid Operation Narrative: A Comparative Study of GPT-4 and Fine-tuned KoELECTRA\n", - "Summary: In the rapidly evolving field of healthcare, the integration of artificial\n", - "intelligence (AI) has become a pivotal component in the automation of clinical\n", - "workflows, ushering in a new era of efficiency and accuracy. This study focuses\n", - "on the transformative capabilities of the fine-tuned KoELECTRA model in\n", - "comparison to the GPT-4 model, aiming to facilitate automated information\n", - "extraction from thyroid operation narratives. The current research landscape is\n", - "dominated by traditional methods heavily reliant on regular expressions, which\n", - "often face challenges in processing free-style text formats containing critical\n", - "details of operation records, including frozen biopsy reports. Addressing this,\n", - "the study leverages advanced natural language processing (NLP) techniques to\n", - "foster a paradigm shift towards more sophisticated data processing systems.\n", - "Through this comparative study, we aspire to unveil a more streamlined,\n", - "precise, and efficient approach to document processing in the healthcare\n", - "domain, potentially revolutionizing the way medical data is handled and\n", - "analyzed.\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Mathematician\n", - "\u001b[0m\n", - "\u001b[33mMathematician\u001b[0m (to chat_manager):\n", - "\n", - "The paper titled \"Automated Information Extraction from Thyroid Operation Narrative: A Comparative Study of GPT-4 and Fine-tuned KoELECTRA\" presents a study on the use of artificial intelligence for automating the extraction of information from thyroid operation narratives. This is a clear example of explainable AI being applied in the medical field, specifically in the area of clinical workflows and document processing.\n", - "\n", - "The potential applications of such technology in medicine are vast. By automating the extraction of information from operation narratives, healthcare professionals can save time and reduce the likelihood of human error. This can lead to more accurate patient records, improved patient care, and streamlined administrative processes. Additionally, the ability to quickly and accurately process operation records can facilitate better data analysis, which can be used for medical research, trend analysis, and improving healthcare outcomes.\n", - "\n", - "The use of advanced natural language processing (NLP) techniques, as mentioned in the summary, is particularly important for processing free-style text formats that contain critical medical information. This technology could be further explored to extend its application to other types of medical documents and records, enhancing the overall efficiency of the healthcare system.\n", - "\n", - "The study's focus on comparing the performance of the fine-tuned KoELECTRA model with GPT-4 also highlights the importance of evaluating different AI models to determine the most effective approach for specific medical applications. This comparative analysis can lead to the development of more specialized AI tools tailored to the needs of the healthcare industry.\n", - "\n", - "In conclusion, the research presented in this paper has significant implications for the future of medical document processing and the broader integration of AI in healthcare.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Programmer\n", - "\u001b[0m\n", - "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", - "\n", - "The insights provided by the Mathematician are indeed valuable. The application of AI for automated information extraction from medical documents like thyroid operation narratives can greatly enhance efficiency and accuracy in healthcare. The use of models like GPT-4 and KoELECTRA for natural language processing tasks shows the potential of AI to handle complex, unstructured data which is common in medical records.\n", - "\n", - "From a programming perspective, the implementation of such AI systems would involve training models on large datasets of medical documents to learn the context and semantics specific to medical terminology. Ensuring the explainability of AI in this context is crucial, as healthcare professionals need to understand and trust the AI's decision-making process, especially when it directly affects patient care.\n", - "\n", - "Moreover, the integration of explainable AI into healthcare systems must adhere to strict privacy and security regulations to protect sensitive patient data. This requires careful design and implementation of data handling procedures within the AI system.\n", - "\n", - "The potential applications extend beyond just document processing to diagnostic assistance, personalized treatment plans, and predictive analytics for patient outcomes. As AI technology continues to evolve, its role in supporting and enhancing the capabilities of healthcare professionals will undoubtedly expand.\n", - "\n", - "Given the importance of the topic and the potential impact on healthcare, it would be beneficial to keep an eye on further developments in this field. If there are no further questions or points to discuss, we can conclude our conversation on this topic.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Mathematician\n", - "\u001b[0m\n", - "\u001b[33mMathematician\u001b[0m (to chat_manager):\n", - "\n", - "I agree with the Programmer's assessment. The implementation of AI in healthcare does indeed require careful consideration of the models used, the training data, and the explainability of the AI's decisions. The ethical implications, particularly concerning patient privacy and data security, are paramount and must be addressed with the utmost rigor.\n", - "\n", - "The potential for AI to assist in diagnostics, treatment planning, and predictive analytics is a promising development for the future of medicine. It is essential that these systems are developed in collaboration with healthcare professionals to ensure they meet the real-world needs of the field.\n", - "\n", - "The interdisciplinary nature of this work, combining expertise in mathematics, computer science, and medicine, is a testament to the collaborative efforts needed to advance healthcare technology. It has been a pleasure discussing the potential applications of explainable AI in medicine with you.\n", - "\n", - "If there are no further points to add, I believe we have reached a natural conclusion to our conversation.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Computer_terminal\n", - "\u001b[0m\n", - "\u001b[33mComputer_terminal\u001b[0m (to chat_manager):\n", - "\n", - "There is no code from the last 1 message for me to execute. Group chat manager should let other participants to continue the conversation. If the group chat manager want to end the conversation, you should let other participant reply me only with \"TERMINATE\"\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mAll agents have been cleared.\u001b[0m\n" - ] - } - ], - "source": [ - "new_builder = AgentBuilder(\n", - " config_file_or_env=config_file_or_env, builder_model=\"gpt-4-1106-preview\", agent_model=\"gpt-4-1106-preview\"\n", - ")\n", - "agent_list, _ = new_builder.build_from_library(building_task, library_path_or_json, llm_config)\n", - "start_task(\n", - " execution_task=\"Find a recent paper about explainable AI on arxiv and find its potential applications in medical.\",\n", - " agent_list=agent_list,\n", - ")\n", - "new_builder.clear_all_agents()" - ] - }, - { - "cell_type": "markdown", - "id": "c7a10e6fa00a5a0d", - "metadata": { - "collapsed": false - }, - "source": [ - "## Build agents from library (by description-task similarity)\n", - "We also support using embedding similarity to select agents. You can use a [Sentence-Transformers model](https://www.sbert.net/docs/pretrained_models.html) as an embedding extractor, and AgentBuilder will select agents with profiles that are the most similar to the building task from the library by comparing their embedding similarity. This will reduce the use of LLMs but may have less accuracy." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "521dc5f961efde59", - "metadata": { - "ExecuteTime": { - "end_time": "2023-12-26T17:01:29.333975100Z", - "start_time": "2023-12-26T16:58:11.070813500Z" - }, - "collapsed": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[32m==> Looking for suitable agents in the library...\u001b[0m\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Programmer', 'Mathematician'] are selected.\n", - "\u001b[32m==> Creating agents...\u001b[0m\n", - "Creating agent Programmer...\n", - "Creating agent Mathematician...\n", - "Adding user console proxy...\n", - "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", - "\n", - "Find a recent paper about gpt-4 on arxiv and find its potential applications in software.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Computer_terminal\n", - "\u001b[0m\n", - "\u001b[33mComputer_terminal\u001b[0m (to chat_manager):\n", - "\n", - "There is no code from the last 1 message for me to execute. Group chat manager should let other participants to continue the conversation. If the group chat manager want to end the conversation, you should let other participant reply me only with \"TERMINATE\"\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Programmer\n", - "\u001b[0m\n", - "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", - "\n", - "To find a recent paper about GPT-4 on arXiv, we can use the arXiv API to search for papers. However, since I can't directly access external APIs, I can write a Python script that you can run on your local machine to perform this search. Would you like me to provide you with such a script?\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Computer_terminal\n", - "\u001b[0m\n", - "\u001b[33mComputer_terminal\u001b[0m (to chat_manager):\n", - "\n", - "There is no code from the last 1 message for me to execute. Group chat manager should let other participants to continue the conversation. If the group chat manager want to end the conversation, you should let other participant reply me only with \"TERMINATE\"\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Programmer\n", - "\u001b[0m\n", - "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", - "\n", - "I apologize for the confusion. I will provide a Python script that can be executed by the Computer_terminal to search for recent papers about GPT-4 on arXiv. Let's proceed with that.\n", - "\n", - "```python\n", - "import requests\n", - "from xml.etree import ElementTree\n", - "\n", - "# Define the search parameters and URL for the arXiv API\n", - "search_query = 'all:gpt-4'\n", - "start = 0\n", - "max_results = 5\n", - "sort_by = 'submittedDate'\n", - "sort_order = 'descending'\n", - "url = f'http://export.arxiv.org/api/query?search_query={search_query}&start={start}&max_results={max_results}&sortBy={sort_by}&sortOrder={sort_order}'\n", - "\n", - "# Send a GET request to the arXiv API\n", - "response = requests.get(url)\n", - "\n", - "# Parse the response if it was successful\n", - "if response.status_code == 200:\n", - " root = ElementTree.fromstring(response.content)\n", - " # Find and print the entries (papers)\n", - " for entry in root.findall('{http://www.w3.org/2005/Atom}entry'):\n", - " title = entry.find('{http://www.w3.org/2005/Atom}title').text\n", - " summary = entry.find('{http://www.w3.org/2005/Atom}summary').text\n", - " published = entry.find('{http://www.w3.org/2005/Atom}published').text\n", - " print(f\"Title: {title}\\nSummary: {summary}\\nPublished Date: {published}\\n\")\n", - "else:\n", - " print(f\"Failed to fetch data from arXiv. Status code: {response.status_code}\")\n", - "```\n", - "\n", - "This script will fetch the most recent papers related to GPT-4 from the arXiv API and print out their titles, summaries, and publication dates. Please execute this script to find the information we need.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Computer_terminal\n", - "\u001b[0m\n", - "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", - "\u001b[33mComputer_terminal\u001b[0m (to chat_manager):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "Title: What If We Recaption Billions of Web Images with LLaMA-3?\n", - "Summary: Web-crawled image-text pairs are inherently noisy. Prior studies demonstrate\n", - "that semantically aligning and enriching textual descriptions of these pairs\n", - "can significantly enhance model training across various vision-language tasks,\n", - "particularly text-to-image generation. However, large-scale investigations in\n", - "this area remain predominantly closed-source. Our paper aims to bridge this\n", - "community effort, leveraging the powerful and \\textit{open-sourced} LLaMA-3, a\n", - "GPT-4 level LLM. Our recaptioning pipeline is simple: first, we fine-tune a\n", - "LLaMA-3-8B powered LLaVA-1.5 and then employ it to recaption 1.3 billion images\n", - "from the DataComp-1B dataset. Our empirical results confirm that this enhanced\n", - "dataset, Recap-DataComp-1B, offers substantial benefits in training advanced\n", - "vision-language models. For discriminative models like CLIP, we observe\n", - "enhanced zero-shot performance in cross-modal retrieval tasks. For generative\n", - "models like text-to-image Diffusion Transformers, the generated images exhibit\n", - "a significant improvement in alignment with users' text instructions,\n", - "especially in following complex queries. Our project page is\n", - "https://www.haqtu.me/Recap-Datacomp-1B/\n", - "\n", - "Published Date: 2024-06-12T17:59:07Z\n", - "\n", - "Title: DafnyBench: A Benchmark for Formal Software Verification\n", - "Summary: We introduce DafnyBench, the largest benchmark of its kind for training and\n", - "evaluating machine learning systems for formal software verification. We test\n", - "the ability of LLMs such as GPT-4 and Claude 3 to auto-generate enough hints\n", - "for the Dafny formal verification engine to successfully verify over 750\n", - "programs with about 53,000 lines of code. The best model and prompting scheme\n", - "achieved 68% success rate, and we quantify how this rate improves when retrying\n", - "with error message feedback and how it deteriorates with the amount of required\n", - "code and hints. We hope that DafnyBench will enable rapid improvements from\n", - "this baseline as LLMs and verification techniques grow in quality.\n", - "\n", - "Published Date: 2024-06-12T17:53:31Z\n", - "\n", - "Title: A Sociotechnical Lens for Evaluating Computer Vision Models: A Case\n", - " Study on Detecting and Reasoning about Gender and Emotion\n", - "Summary: In the evolving landscape of computer vision (CV) technologies, the automatic\n", - "detection and interpretation of gender and emotion in images is a critical area\n", - "of study. This paper investigates social biases in CV models, emphasizing the\n", - "limitations of traditional evaluation metrics such as precision, recall, and\n", - "accuracy. These metrics often fall short in capturing the complexities of\n", - "gender and emotion, which are fluid and culturally nuanced constructs. Our\n", - "study proposes a sociotechnical framework for evaluating CV models,\n", - "incorporating both technical performance measures and considerations of social\n", - "fairness. Using a dataset of 5,570 images related to vaccination and climate\n", - "change, we empirically compared the performance of various CV models, including\n", - "traditional models like DeepFace and FER, and generative models like GPT-4\n", - "Vision. Our analysis involved manually validating the gender and emotional\n", - "expressions in a subset of images to serve as benchmarks. Our findings reveal\n", - "that while GPT-4 Vision outperforms other models in technical accuracy for\n", - "gender classification, it exhibits discriminatory biases, particularly in\n", - "response to transgender and non-binary personas. Furthermore, the model's\n", - "emotion detection skew heavily towards positive emotions, with a notable bias\n", - "towards associating female images with happiness, especially when prompted by\n", - "male personas. These findings underscore the necessity of developing more\n", - "comprehensive evaluation criteria that address both validity and discriminatory\n", - "biases in CV models. Our proposed framework provides guidelines for researchers\n", - "to critically assess CV tools, ensuring their application in communication\n", - "research is both ethical and effective. The significant contribution of this\n", - "study lies in its emphasis on a sociotechnical approach, advocating for CV\n", - "technologies that support social good and mitigate biases rather than\n", - "perpetuate them.\n", - "\n", - "Published Date: 2024-06-12T13:52:30Z\n", - "\n", - "Title: Supportiveness-based Knowledge Rewriting for Retrieval-augmented\n", - " Language Modeling\n", - "Summary: Retrieval-augmented language models (RALMs) have recently shown great\n", - "potential in mitigating the limitations of implicit knowledge in LLMs, such as\n", - "untimely updating of the latest expertise and unreliable retention of long-tail\n", - "knowledge. However, since the external knowledge base, as well as the\n", - "retriever, can not guarantee reliability, potentially leading to the knowledge\n", - "retrieved not being helpful or even misleading for LLM generation. In this\n", - "paper, we introduce Supportiveness-based Knowledge Rewriting (SKR), a robust\n", - "and pluggable knowledge rewriter inherently optimized for LLM generation.\n", - "Specifically, we introduce the novel concept of \"supportiveness\"--which\n", - "represents how effectively a knowledge piece facilitates downstream tasks--by\n", - "considering the perplexity impact of augmented knowledge on the response text\n", - "of a white-box LLM. Based on knowledge supportiveness, we first design a\n", - "training data curation strategy for our rewriter model, effectively identifying\n", - "and filtering out poor or irrelevant rewrites (e.g., with low supportiveness\n", - "scores) to improve data efficacy. We then introduce the direct preference\n", - "optimization (DPO) algorithm to align the generated rewrites to optimal\n", - "supportiveness, guiding the rewriter model to summarize augmented content that\n", - "better improves the final response. Comprehensive evaluations across six\n", - "popular knowledge-intensive tasks and four LLMs have demonstrated the\n", - "effectiveness and superiority of SKR. With only 7B parameters, SKR has shown\n", - "better knowledge rewriting capability over GPT-4, the current state-of-the-art\n", - "general-purpose LLM.\n", - "\n", - "Published Date: 2024-06-12T11:52:35Z\n", - "\n", - "Title: Automated Information Extraction from Thyroid Operation Narrative: A\n", - " Comparative Study of GPT-4 and Fine-tuned KoELECTRA\n", - "Summary: In the rapidly evolving field of healthcare, the integration of artificial\n", - "intelligence (AI) has become a pivotal component in the automation of clinical\n", - "workflows, ushering in a new era of efficiency and accuracy. This study focuses\n", - "on the transformative capabilities of the fine-tuned KoELECTRA model in\n", - "comparison to the GPT-4 model, aiming to facilitate automated information\n", - "extraction from thyroid operation narratives. The current research landscape is\n", - "dominated by traditional methods heavily reliant on regular expressions, which\n", - "often face challenges in processing free-style text formats containing critical\n", - "details of operation records, including frozen biopsy reports. Addressing this,\n", - "the study leverages advanced natural language processing (NLP) techniques to\n", - "foster a paradigm shift towards more sophisticated data processing systems.\n", - "Through this comparative study, we aspire to unveil a more streamlined,\n", - "precise, and efficient approach to document processing in the healthcare\n", - "domain, potentially revolutionizing the way medical data is handled and\n", - "analyzed.\n", - "\n", - "Published Date: 2024-06-12T06:44:05Z\n", - "\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Programmer\n", - "\u001b[0m\n", - "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", - "\n", - "Based on the search results from the arXiv API, we have found several papers that discuss potential applications of GPT-4 in software:\n", - "\n", - "1. **Recaptioning Web Images with LLaMA-3 and GPT-4**: This paper discusses the use of GPT-4 level LLMs for recaptioning web images, which can enhance model training across various vision-language tasks. This has implications for improving the quality of datasets used in machine learning and could be particularly beneficial for text-to-image generation and cross-modal retrieval tasks.\n", - "\n", - "2. **DafnyBench: A Benchmark for Formal Software Verification**: This paper introduces a benchmark for training and evaluating machine learning systems for formal software verification. It tests the ability of LLMs such as GPT-4 to auto-generate hints for the Dafny formal verification engine to successfully verify programs. This application could significantly impact the field of software verification by automating the generation of verification hints, potentially improving the efficiency and reliability of the verification process.\n", - "\n", - "3. **Automated Information Extraction from Thyroid Operation Narrative**: This study compares the GPT-4 model with the fine-tuned KoELECTRA model for automated information extraction from thyroid operation narratives. The application of GPT-4 in this context could revolutionize document processing in healthcare by providing a more efficient and accurate method for extracting information from medical records.\n", - "\n", - "These papers suggest that GPT-4 has the potential to be applied in various software-related fields, including enhancing datasets for machine learning, formal software verification, and healthcare document processing. The applications in these papers could lead to more efficient, accurate, and reliable software systems across different domains.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Mathematician\n", - "\u001b[0m\n", - "\u001b[33mMathematician\u001b[0m (to chat_manager):\n", - "\n", - "The applications mentioned indeed highlight the versatility of GPT-4 in different domains. To further understand the potential impact of GPT-4 on software, let's delve into the mathematical and algorithmic principles that could be at play in these applications:\n", - "\n", - "1. **Recaptioning Web Images**: The process of recaptioning images with a language model like GPT-4 involves understanding the context of an image and generating descriptive text that accurately reflects its content. This task likely involves a combination of computer vision techniques to interpret the image and natural language processing to generate the caption. From a mathematical perspective, this would involve optimization algorithms to fine-tune the language model on a specific dataset, ensuring that the generated captions are both semantically and syntactically correct.\n", - "\n", - "2. **Formal Software Verification**: The use of GPT-4 to auto-generate hints for formal verification engines like Dafny involves the model understanding the logic and structure of the code. This requires a deep understanding of formal logic, proof theory, and possibly type theory if the language being verified is statically typed. The success rate of auto-generated hints would depend on the model's ability to reason about the correctness of code and the underlying mathematical properties that ensure its validity.\n", - "\n", - "3. **Automated Information Extraction from Medical Records**: For GPT-4 to extract information from medical narratives, it must process unstructured text and identify relevant medical terms and their relationships. This task involves natural language understanding, which from a mathematical standpoint, can be seen as a form of pattern recognition and classification. The model would need to be trained on a large corpus of medical texts, and its performance would be measured by its precision and recall in identifying and extracting the correct information.\n", - "\n", - "In each of these applications, GPT-4's effectiveness would be influenced by the underlying mathematical models, such as neural networks, and the optimization techniques used during training, such as gradient descent. The quality of the training data and the model's architecture (e.g., attention mechanisms, transformer layers) also play a crucial role in its performance.\n", - "\n", - "To verify the potential of GPT-4 in these applications, one could set up experiments to measure the performance of GPT-4 against specific benchmarks or metrics relevant to each domain. For example, in the case of formal software verification, one could measure the percentage of programs that are successfully verified with the hints generated by GPT-4 compared to a baseline or human-generated hints.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Mathematician\n", - "\u001b[0m\n", - "\u001b[33mMathematician\u001b[0m (to chat_manager):\n", - "\n", - "To further verify the potential applications of GPT-4 in software, we can consider the following:\n", - "\n", - "1. **Recaptioning Web Images**: The effectiveness of GPT-4 in this application can be measured by the accuracy of the captions it generates. This can be quantified using metrics such as BLEU (Bilingual Evaluation Understudy) or ROUGE (Recall-Oriented Understudy for Gisting Evaluation), which compare the machine-generated text to a set of reference captions. A high score on these metrics would indicate that GPT-4 is capable of understanding and describing the content of images accurately.\n", - "\n", - "2. **Formal Software Verification**: To verify the application of GPT-4 in software verification, we could measure the success rate of the model in generating verification hints that lead to successful program verification. This could be done by comparing the verification success rate with and without the hints provided by GPT-4. Additionally, the complexity of the programs and the hints required could be analyzed to understand the model's limitations and strengths.\n", - "\n", - "3. **Automated Information Extraction from Medical Records**: The performance of GPT-4 in extracting information from medical narratives can be assessed by comparing the extracted information to a gold standard set of annotations. Precision, recall, and F1-score are common metrics used to evaluate information extraction systems. A high F1-score would suggest that GPT-4 is effective in identifying and extracting relevant information from unstructured medical texts.\n", - "\n", - "For each of these applications, it would be important to conduct a thorough analysis of the results to ensure that the model's performance is not only statistically significant but also practically relevant. Additionally, it would be crucial to assess the model's performance on diverse datasets to ensure that it generalizes well across different contexts and does not exhibit biases that could lead to incorrect or unfair outcomes.\n", - "\n", - "If we want to simulate or test these applications, we could propose specific experiments or data analysis procedures that align with the above verification strategies. However, such experiments would require access to the relevant datasets and computational resources to run the models, which may not be feasible within the scope of this conversation.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Mathematician\n", - "\u001b[0m\n", - "\u001b[33mMathematician\u001b[0m (to chat_manager):\n", - "\n", - "To simulate or test these applications, we could propose specific experiments or data analysis procedures that align with the above verification strategies. However, such experiments would require access to the relevant datasets and computational resources to run the models, which may not be feasible within the scope of this conversation.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[32m\n", - "Next speaker: Mathematician\n", - "\u001b[0m\n", - "\u001b[33mMathematician\u001b[0m (to chat_manager):\n", - "\n", - "TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mAll agents have been cleared.\u001b[0m\n" - ] - } - ], - "source": [ - "new_builder = AgentBuilder(\n", - " config_file_or_env=config_file_or_env, builder_model=\"gpt-4-1106-preview\", agent_model=\"gpt-4-1106-preview\"\n", - ")\n", - "agent_list, _ = new_builder.build_from_library(\n", - " building_task, library_path_or_json, llm_config, embedding_model=\"all-mpnet-base-v2\"\n", - ")\n", - "start_task(\n", - " execution_task=\"Find a recent paper about gpt-4 on arxiv and find its potential applications in software.\",\n", - " agent_list=agent_list,\n", - ")\n", - "new_builder.clear_all_agents()" + "cells": [ + { + "cell_type": "markdown", + "id": "6264276d39875995", + "metadata": { + "collapsed": false + }, + "source": [ + "# Automatically Build Multi-agent System from Agent Library\n", + "\n", + "By: [Linxin Song](https://linxins97.github.io/), [Jieyu Zhang](https://jieyuz2.github.io/)\n", + "\n", + "In this notebook, we introduce a new feature for AutoBuild, `build_from_library`, which help users build an automatic task-solving process powered by a multi-agent system from a pre-defined agent library. \n", + "Specifically, in `build_from_library`, we prompt an LLM to explore useful agents from a pre-defined agent library, generating configurations for those agents for a group chat to solve the user's task." + ] + }, + { + "cell_type": "markdown", + "id": "ec78dda8e3826d8a", + "metadata": { + "collapsed": false + }, + "source": [ + "## Requirement\n", + "\n", + "AutoBuild require `autogen[autobuild]`, which can be installed by the following command:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e8e9ae50658be975", + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%pip install autogen[autobuild]" + ] + }, + { + "cell_type": "markdown", + "id": "176c200804af63f3", + "metadata": { + "collapsed": false + }, + "source": [ + "## Preparation and useful tools\n", + "We need to specify a `config_path`, `default_llm_config` that include backbone LLM configurations." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2505f029423b21ab", + "metadata": { + "ExecuteTime": { + "end_time": "2023-12-26T16:58:02.762702600Z", + "start_time": "2023-12-26T16:58:02.472073Z" + }, + "collapsed": false + }, + "outputs": [], + "source": [ + "import json\n", + "\n", + "import autogen\n", + "from autogen.agentchat.contrib.agent_builder import AgentBuilder\n", + "\n", + "config_file_or_env = \"OAI_CONFIG_LIST\" # modify path\n", + "llm_config = {\"temperature\": 0}\n", + "config_list = autogen.config_list_from_json(config_file_or_env, filter_dict={\"model\": [\"gpt-4-1106-preview\", \"gpt-4\"]})\n", + "\n", + "\n", + "def start_task(execution_task: str, agent_list: list):\n", + " group_chat = autogen.GroupChat(agents=agent_list, messages=[], max_round=12)\n", + " manager = autogen.GroupChatManager(groupchat=group_chat, llm_config={\"config_list\": config_list, **llm_config})\n", + " agent_list[0].initiate_chat(manager, message=execution_task)" + ] + }, + { + "cell_type": "markdown", + "id": "5fb3db8885dd6ee6", + "metadata": { + "collapsed": false + }, + "source": [ + "## Example for generating an agent library\n", + "Here, we show an example of generating an agent library from a pre-defined list of agents' names by prompting a `gpt-4`. You can also prepare a handcrafted library yourself.\n", + "\n", + "A Library contains each agent's name, description and system_message. The description is a brief introduction about agent's characteristics. As we will feed all agents' names and description to gpt-4 and let it choose the best agents for us, each agent's description should be simple but informative. \n", + "\n", + "First, we define a prompt template for description and system_message generation and a list of agents' name:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "68315f6ec912c58a", + "metadata": { + "ExecuteTime": { + "end_time": "2023-12-23T07:39:03.317527600Z", + "start_time": "2023-12-23T07:39:03.276859600Z" + }, + "collapsed": false + }, + "outputs": [], + "source": [ + "AGENT_SYS_MSG_PROMPT = \"\"\"Acccording to the following postion name, write a high quality instruction for the position following a given example. You should only return the instruction.\n", + "\n", + "# Position Name\n", + "{position}\n", + "\n", + "# Example instruction for Data Analyst\n", + "\n", + "As Data Analyst, you are tasked with leveraging your extensive knowledge in data analysis to recognize and extract meaningful features from vast datasets. Your expertise in machine learning, specifically with the Random Forest Classifier, allows you to construct robust predictive models adept at handling both classification and regression tasks. You excel in model evaluation and interpretation, ensuring that the performance of your algorithms is not just assessed with precision, but also understood in the context of the data and the problem at hand. With a command over Python and proficiency in using the pandas library, you manipulate and preprocess data with ease.\n", + "\"\"\"\n", + "\n", + "AGENT_DESC_PROMPT = \"\"\"According to position name and the instruction, summarize the position into a high quality one sentence description.\n", + "\n", + "# Position Name\n", + "{position}\n", + "\n", + "# Instruction\n", + "{instruction}\n", + "\"\"\"\n", + "\n", + "position_list = [\n", + " \"Environmental_Scientist\",\n", + " \"Astronomer\",\n", + " \"Software_Developer\",\n", + " \"Data_Analyst\",\n", + " \"Journalist\",\n", + " \"Teacher\",\n", + " \"Lawyer\",\n", + " \"Programmer\",\n", + " \"Accountant\",\n", + " \"Mathematician\",\n", + " \"Physicist\",\n", + " \"Biologist\",\n", + " \"Chemist\",\n", + " \"Statistician\",\n", + " \"IT_Specialist\",\n", + " \"Cybersecurity_Expert\",\n", + " \"Artificial_Intelligence_Engineer\",\n", + " \"Financial_Analyst\",\n", + "]" + ] + }, + { + "cell_type": "markdown", + "id": "72b8e7d9d334a5c2", + "metadata": { + "collapsed": false + }, + "source": [ + "Then we can prompt a `gpt-4` model to generate each agent's system message as well as the description:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8fbfef9268fc5191", + "metadata": { + "ExecuteTime": { + "end_time": "2023-12-23T07:40:01.703372Z", + "start_time": "2023-12-23T07:39:04.472589200Z" + }, + "collapsed": false + }, + "outputs": [], + "source": [ + "build_manager = autogen.OpenAIWrapper(config_list=config_list)\n", + "sys_msg_list = []\n", + "\n", + "for pos in position_list:\n", + " resp_agent_sys_msg = (\n", + " build_manager.create(\n", + " messages=[\n", + " {\n", + " \"role\": \"user\",\n", + " \"content\": AGENT_SYS_MSG_PROMPT.format(\n", + " position=pos,\n", + " ),\n", + " }\n", + " ]\n", + " )\n", + " .choices[0]\n", + " .message.content\n", + " )\n", + " resp_desc_msg = (\n", + " build_manager.create(\n", + " messages=[\n", + " {\n", + " \"role\": \"user\",\n", + " \"content\": AGENT_DESC_PROMPT.format(\n", + " position=pos,\n", + " instruction=resp_agent_sys_msg,\n", + " ),\n", + " }\n", + " ]\n", + " )\n", + " .choices[0]\n", + " .message.content\n", + " )\n", + " sys_msg_list.append({\"name\": pos, \"system_message\": resp_agent_sys_msg, \"description\": resp_desc_msg})" + ] + }, + { + "cell_type": "markdown", + "id": "9e26c6db4befacc5", + "metadata": { + "collapsed": false + }, + "source": [ + "The generated profile will have the following format:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8ede1d7088eb183d", + "metadata": { + "ExecuteTime": { + "end_time": "2023-12-23T07:40:01.712399300Z", + "start_time": "2023-12-23T07:40:01.707400200Z" + }, + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'name': 'Environmental_Scientist',\n", + " 'system_message': 'As an Environmental Scientist, you are responsible for applying your profound knowledge of environmental science to analyze ecological data and assess the impact of human activities on natural resources and ecosystems. Your proficiency in environmental assessment techniques enables you to design and conduct field studies, collect samples, and monitor environmental parameters effectively. Utilizing Geographic Information Systems (GIS), you spatially analyze and visualize environmental data to better understand patterns and changes in the landscape. You are adept at interpreting the results and communicating your findings clearly to stakeholders, policymakers, and the public, thereby contributing to informed decision-making on environmental issues. Your role is essential in developing sustainable practices and recommending mitigation measures to minimize environmental degradation and promote conservation.',\n", + " 'description': 'As an Environmental Scientist, you are tasked with analyzing and assessing the impact of human activities on ecosystems by conducting field studies, using GIS for spatial analysis, and communicating your findings to inform sustainable practices and conservation efforts.'},\n", + " {'name': 'Astronomer',\n", + " 'system_message': 'As an Astronomer, your duty involves diligent observation and analysis of celestial phenomena across the universe. Utilize cutting-edge telescopes and instruments to gather astronomical data, looking for patterns and irregularities that can lead to groundbreaking discoveries. Your profound knowledge in astrophysics is pivotal in interpreting these findings, which may include identifying new celestial objects, scrutinizing the properties and behaviors of stars, planets, and galaxies, and understanding cosmic events. Mastery of complex astronomical software and advanced mathematics is crucial for modeling astronomical phenomena and processing the vast amounts of data. Your role is essential in advancing our understanding of the cosmos, contributing to the broader scientific community by publishing your findings in reputable journals and engaging in peer collaboration to further space exploration and research.',\n", + " 'description': 'An Astronomer is a professional who meticulously observes, analyzes, and interprets celestial phenomena using advanced telescopes and instruments, requiring a deep knowledge of astrophysics, proficiency in mathematical modeling, and collaboration in scientific communities to enhance our comprehension of the universe.'},\n", + " {'name': 'Software_Developer',\n", + " 'system_message': 'As a Software Developer, your objective is to craft, test, and maintain the software that will meet the needs of our users and clients. Your proficiency in programming languages such as Java, C#, or JavaScript is essential, enabling you to write clean, efficient, and maintainable code. You will design algorithms and flowcharts to create systems that are logical and user-friendly. Collaboration with cross-functional teams, including product managers and designers, is crucial in order to understand software requirements and deliver innovative solutions. With your understanding of the software development life cycle, you will work through the processes of coding, debugging, testing, and deployment. You will employ industry best practices such as version control with Git and conduct code reviews to maintain high standards of software quality. Your role places you at the heart of our development efforts, where your technical prowess advances the functionality, scalability, and reliability of our software products.',\n", + " 'description': 'A Software Developer is responsible for designing, coding, testing, and maintaining software that meets client needs using languages like Java, C#, or JavaScript, collaborating with teams, adhering to best practices like Git for version control, and ensuring quality and innovation throughout the development life cycle.'},\n", + " {'name': 'Data_Analyst',\n", + " 'system_message': 'As a Data Analyst, your role is pivotal in interpreting complex data and providing insights that inform strategic decision-making. Utilize your analytical skills to cleanse and organize large sets of structured and unstructured data, ensuring its accuracy and readiness for in-depth analysis. Apply statistical analysis and predictive modeling to uncover trends, patterns, and correlations that drive operational improvements and innovative solutions. Use your proficiency in SQL for database interactions, and harness visualization tools such as Tableau or Power BI to craft compelling stories from data, aiding stakeholders in visualizing the implications of your findings. Stay abreast with the latest analytics techniques and continuously refine your models for enhanced performance, contributing significantly to the data-driven culture of our organization.',\n", + " 'description': 'The Data Analyst interprets complex datasets to provide strategic insights, cleanses and organizes data, performs statistical analysis and predictive modeling to identify trends and inform improvements, utilizes SQL for database management, and employs visualization tools like Tableau or Power BI to effectively communicate findings to stakeholders.'},\n", + " {'name': 'Journalist',\n", + " 'system_message': 'As a Journalist, you are responsible for identifying and pursuing newsworthy stories with the utmost ethical standards and a commitment to factual reporting. Your innate curiosity and excellent communication skills enable you to conduct thorough research and interviews, uncovering the details that make each story compelling and informative. Skilled in both written and verbal storytelling, you craft articles, reports, and features that engage and inform the public, adhering to strict deadlines without compromising on the integrity and accuracy of your work. Proficient in multimedia journalism, you adeptly use digital tools and social media to reach a wider audience, ensuring that your stories have the maximum impact.',\n", + " 'description': 'A Journalist is tasked with ethically sourcing and meticulously reporting newsworthy events, utilizing strong research and storytelling abilities across multiple platforms to accurately inform and engage a diverse audience.'},\n", + " {'name': 'Teacher',\n", + " 'system_message': 'As a Teacher, you are entrusted with the essential responsibility of fostering knowledge and encouraging academic and personal growth in your students. Your deep understanding of pedagogy, coupled with your expertise in the subject matter, enables you to create and deliver curricula that are both engaging and educational. Your adeptness at differentiated instruction allows you to tailor your teaching methods to suit the varied learning styles and needs within your classroom. By skillfully blending traditional teaching techniques with modern educational technology, you facilitate a dynamic and interactive learning environment. You excel in assessment and feedback, not only to gauge student progress but also to continuously improve your own teaching strategies. With strong interpersonal skills, you maintain open lines of communication with students, parents, and colleagues, fostering a collaborative and supportive school community.',\n", + " 'description': \"A Teacher is responsible for cultivating students' knowledge and growth through expertise in pedagogical practices and subject matter, designing engaging curricula, adapting teaching methods to diverse learning needs, integrating technology, and using assessment for continuous improvement while nurturing a cooperative school community.\"},\n", + " {'name': 'Lawyer',\n", + " 'system_message': 'As a Lawyer, you are required to uphold the highest standards of legal proficiency and ethical practice. Your role involves advising clients on their legal rights and responsibilities, as well as representing them in civil and criminal proceedings. You must possess a strong understanding of the law, paired with the ability to analyze case law and legislate history, to construct compelling arguments in support of your client’s position. Your keen attention to detail and dedication to thorough research are crucial in identifying legal precedents and crafting legal documents that adhere to the strictest of procedural standards. Moreover, you must exhibit exceptional negotiation skills to achieve favorable outcomes, whether in the courtroom or at the settlement table. With your articulate verbal and written communication, you clearly and persuasively present cases, explaining complex legal concepts in understandable terms to clients, judges, and juries. Your commitment to confidentiality and upholding justice is paramount and reflected in all aspects of your professional conduct.',\n", + " 'description': 'A Lawyer is a professionally trained legal advocate responsible for representing clients in legal proceedings, providing expert advice on legal matters, constructing persuasive arguments through meticulous research and analysis of law, and negotiating settlements, all while adhering to the highest ethical standards and maintaining strict confidentiality.'},\n", + " {'name': 'Programmer',\n", + " 'system_message': 'As a Programmer, you are responsible for the design, development, and implementation of software programs. Utilize your comprehensive understanding of programming languages, including but not limited to Java, C++, and Python, to create efficient and innovative software solutions. Your role involves writing clean, maintainable code while adhering to best practices in software development. You are expected to troubleshoot, debug, and upgrade existing software, as well as collaborate with cross-functional teams to define and design new product features. Your ability to think algorithmically and solve problems systematically will be integral in creating software that is not only functional but also scalable and secure.',\n", + " 'description': 'A Programmer designs, develops, and implements innovative and efficient software solutions using languages like Java, C++, and Python, ensuring code maintainability, collaborating on new features, and enhancing existing applications with a strong focus on scalability and security.'},\n", + " {'name': 'Accountant',\n", + " 'system_message': 'As Accountant, you are charged with the meticulous management and analysis of financial records, ensuring accuracy and compliance with relevant laws and regulations. Utilize your comprehensive understanding of accounting principles to prepare, examine, and maintain financial reports and statements, including balance sheets and income statements. Your role involves the reconciliation of accounts, evaluating financial operations to recommend best practices, identifying issues, and strategizing solutions for fiscal efficiency and profitability. Mastery in accounting software such as QuickBooks or Sage, alongside proficiency in Microsoft Excel, enables you to efficiently process and analyze financial data. You must ensure proper financial documentation and control systems are in place, providing comprehensive support to the organization’s financial health and integrity.',\n", + " 'description': 'As an Accountant, you are responsible for the accurate and compliant management, analysis, and reporting of financial data, along with recommending strategies to enhance fiscal efficiency and profitability, supported by proficiency in accounting software and Microsoft Excel.'},\n", + " {'name': 'Mathematician',\n", + " 'system_message': 'As a Mathematician, you are responsible for utilizing your profound understanding of mathematical theories and methodologies to solve complex theoretical and practical problems across various domains. Your proficiency in abstract reasoning enables you to develop new mathematical principles and to recognize and articulate the underlying mathematical relationships within real-world scenarios. You apply your expertise in calculus, algebra, statistics, and other mathematical branches to conduct rigorous analyses and to model systems for prediction and optimization. With a strong foundation in logic and quantitative reasoning, you perform peer reviews and contribute to interdisciplinary research projects, ensuring accuracy and consistency in mathematical arguments and results. Your role is crucial in advancing mathematical knowledge and providing innovative solutions to scientific and engineering challenges.',\n", + " 'description': 'As a Mathematician, you apply advanced mathematical theories and analytical skills to solve theoretical and practical problems in various industries, develop new principles, and provide innovative solutions to complex scientific and engineering challenges.'},\n", + " {'name': 'Physicist',\n", + " 'system_message': 'As a Physicist, you are charged with applying your profound understanding of the physical laws that govern the universe to unravel complex scientific phenomena. Your proficiency in theoretical and experimental physics enables you to develop models and conduct experiments that explore fundamental forces and particles. With exceptional analytical skills, you interpret empirical data to validate existing theories or propose new explanations for unexplained observations. Mastery in the use of mathematical tools such as differential equations and linear algebra is crucial for you to simulate physical processes. You are also adept at using specialized software and equipment for data acquisition and analysis, contributing to advancements in fields ranging from quantum mechanics to cosmology. Your strong critical thinking abilities empower you to solve intricate problems, and your commitment to scientific rigor ensures the integrity and accuracy of your research outcomes.',\n", + " 'description': 'A Physicist applies deep knowledge of physical laws to investigate scientific phenomena through theoretical modeling and experimental research, utilizing advanced mathematical techniques and specialized equipment to advance understanding in areas such as quantum mechanics and cosmology.'},\n", + " {'name': 'Biologist',\n", + " 'system_message': 'As a Biologist, you are entrusted with the study and understanding of living organisms, applying your expertise to investigate their functions, genetics, evolution, and ecosystems. Your skills in experimental design empower you to conduct research and experiments that can unlock new biological insights and improve our comprehension of life processes. Utilizing advanced microscopy techniques and molecular biology methods, you should meticulously analyze cell structures and DNA sequences to uncover the intricacies of life at a microscopic level. Demonstrate proficiency in bioinformatics tools to analyze genetic data and contribute valuable findings to the scientific community. Furthermore, as a communicator of science, ensure that your research findings are effectively documented and presented in scientific journals and at conferences, thereby enhancing the collective knowledge in your field.',\n", + " 'description': 'A Biologist meticulously studies and understands living organisms, conducting advanced research to decode genetics and ecosystems and sharing findings through scientific publications and presentations.'},\n", + " {'name': 'Chemist',\n", + " 'system_message': 'As a Chemist, you are charged with applying your profound understanding of chemical principles to conduct complex experiments, synthesize new compounds, and analyze the molecular and atomic structure of materials. Your proficiency in utilizing sophisticated analytical techniques - such as chromatography, spectroscopy, and mass spectrometry - enables you to decipher the composition and properties of substances. The knowledge you hold in chemical safety and handling procedures ensures a secure laboratory environment. With an adeptness in maintaining accurate records and an insightful approach to interpreting data, you transform raw experimental results into valuable scientific insights. Your ability to communicate complex chemical information clearly makes you essential in collaborative research efforts and in driving innovation within the field.',\n", + " 'description': 'As a Chemist, you are responsible for conducting advanced experiments, synthesizing compounds, deciphering substance compositions with techniques like chromatography and mass spectrometry, and transforming experimental data into scientific insights, while maintaining safety and clear communication in research collaborations.'},\n", + " {'name': 'Statistician',\n", + " 'system_message': 'As a Statistician, your primary duty is to apply mathematical and statistical methods to collect, analyze, and interpret numerical data to make informed decisions. Your strong grounding in probability theory will be essential for designing surveys and experiments to generate data. You are adept at constructing and applying sophisticated statistical models and methods, such as linear regression, ANOVA, or time-series analysis, ensuring that you accurately capture trends and relationships within the data. You possess an in-depth understanding of statistical software such as R or SAS, allowing you to perform complex analyses with efficiency and precision. Your ability to communicate complex statistical concepts to non-experts will be crucial; hence, your role includes presenting findings in a clear, actionable manner, with data visualizations and reports that drive strategic planning and policy development.',\n", + " 'description': 'A Statistician employs and interprets advanced statistical techniques to design data-collection processes, analyze data, and present findings in a comprehensible manner, supporting evidence-based decision-making and policy formation.'},\n", + " {'name': 'IT_Specialist',\n", + " 'system_message': 'As an IT Specialist, your primary responsibility is to maintain the integrity and functionality of all our computer systems and networks. Your comprehensive understanding of hardware and software is crucial for diagnosing and resolving technical issues. You are adept at implementing network security measures to protect data and systems from cyber threats. You also play a significant role in systems and software upgrades, ensuring a seamless transition without disrupting workflow. Utilizing your strong problem-solving skills and proficiency in scripting languages, you automate repetitive tasks, enhancing system efficiency. Your ability to communicate effectively with team members and non-technical staff allows you to provide clear guidance and end-user support.',\n", + " 'description': 'An IT Specialist is responsible for upholding and optimizing our computer systems and networks through maintenance, security, upgrades, issue resolution, automation, and providing support and clear communication to both technical and non-technical personnel.'},\n", + " {'name': 'Cybersecurity_Expert',\n", + " 'system_message': \"As a Cybersecurity Expert, you are charged with the responsibility of safeguarding the organization's computer networks and systems. Your deep understanding of cyber threats and mitigation techniques is critical in identifying vulnerabilities and protecting against malicious attacks. Employing your experience with tools such as firewalls, antivirus software, and intrusion detection systems, you will continuously monitor and defend our digital infrastructure. You are expected to conduct regular security audits and penetration testing to simulate cyber attacks and find potential weaknesses before they can be exploited. Your proficiency in risk management frameworks and incident response protocols ensures that you are prepared to swiftly handle and mitigate any security incidents that occur. With your expertise in encryption technologies and network protocols, you protect sensitive data and ensure compliance with relevant security standards and regulations. Your foresight in staying up-to-date with the latest cybersecurity trends and threats is paramount to maintaining the organization's digital defense at its peak.\",\n", + " 'description': \"As a Cybersecurity Expert, you are responsible for the proactive protection and defense of an organization's computer networks and systems against cyber threats through continuous monitoring, conducting security audits, penetrating testing, and swiftly mitigating security incidents, while ensuring compliance with security regulations.\"},\n", + " {'name': 'Artificial_Intelligence_Engineer',\n", + " 'system_message': 'As an Artificial Intelligence Engineer, you are responsible for conceptualizing, designing, and implementing intelligent systems that simulate human cognitive processes. Your role demands a deep understanding of neural networks, particularly Convolutional Neural Networks (CNNs) for image recognition tasks and Recurrent Neural Networks (RNNs) for natural language processing. With your expertise in TensorFlow or PyTorch, you develop complex models that can learn, adapt, and make decisions. You prioritize the ethical design and deployment of AI systems, conscious of the implications your work may have on society. Mastery of algorithms and a proficiency in a high-level programming language, preferably Python, enable you to transform theoretical AI concepts into practical solutions that drive innovation and efficiency.',\n", + " 'description': 'An Artificial Intelligence Engineer specializes in creating and implementing advanced intelligent systems, with a mastery of neural networks, machine learning frameworks, and ethical AI principles, to develop innovative solutions that emulate human cognition.'},\n", + " {'name': 'Financial_Analyst',\n", + " 'system_message': 'As a Financial Analyst, you are entrusted with utilizing your in-depth understanding of financial principles to assess investment opportunities, analyze financial data, and forecast economic trends. Your proficiency in financial modeling is paramount, enabling you to develop complex models that underpin the valuation of stocks, bonds, and other financial instruments. With a sharp eye for detail, you scrutinize company financial statements to derive actionable insights and recommend strategies to optimize financial performance. Your expertise in Excel, especially with advanced functions and formulas, allows you to efficiently manipulate and analyze large financial datasets. You are a whiz at creating compelling visualizations and delivering presentations to communicate your findings and influence strategic decisions. Your role is crucial in guiding investment decisions and driving the fiscal prudence of the organization.',\n", + " 'description': \"A Financial Analyst performs in-depth financial analysis and modeling to evaluate investments, forecast economic trends, and deliver strategic recommendations, leveraging advanced Excel skills to inform and guide the organization's financial decisions.\"}]" ] - } - ], - "metadata": { - "front_matter": { - "description": "Automatically build multi-agent system from agent library", - "tags": [ - "autobuild" - ] - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.14" - } + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sys_msg_list" + ] + }, + { + "cell_type": "markdown", + "id": "256dd32b03a7a172", + "metadata": { + "collapsed": false + }, + "source": [ + "We can save the generated agents' information into a json file." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "53111125938845cf", + "metadata": { + "ExecuteTime": { + "end_time": "2023-12-23T07:40:01.750855900Z", + "start_time": "2023-12-23T07:40:01.710399600Z" + }, + "collapsed": false + }, + "outputs": [], + "source": [ + "json.dump(sys_msg_list, open(\"./agent_library_example.json\", \"w\"), indent=4)" + ] + }, + { + "cell_type": "markdown", + "id": "cfd883b79a3bd932", + "metadata": { + "collapsed": false + }, + "source": [ + "## Build agents from library (by LLM)\n", + "Here, we introduce how to build agents from the generated library. As in the previous `build`, we also need to specify a `building_task` that lets the build manager know which agents should be selected from the library according to the task. \n", + "\n", + "We also need to specify a `library_path_or_json`, which can be a path of library or a JSON string with agents' configs. Here, we use the previously saved path as the library path." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8963a8709c8e92e2", + "metadata": { + "ExecuteTime": { + "end_time": "2023-12-23T07:40:01.752918500Z", + "start_time": "2023-12-23T07:40:01.735461Z" + }, + "collapsed": false + }, + "outputs": [], + "source": [ + "library_path_or_json = \"./agent_library_example.json\"\n", + "building_task = \"Find a paper on arxiv by programming, and analyze its application in some domain. For example, find a recent paper about gpt-4 on arxiv and find its potential applications in software.\"" + ] + }, + { + "cell_type": "markdown", + "id": "72656a8d0c1a9b12", + "metadata": { + "collapsed": false + }, + "source": [ + "Then, we can call the `build_from_library` from the AgentBuilder to generate a list of agents from the library and let them complete the user's `execution_task` in a group chat." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5c669b76b2c9b750", + "metadata": { + "ExecuteTime": { + "end_time": "2023-12-23T07:46:02.075542200Z", + "start_time": "2023-12-23T07:43:55.489042900Z" + }, + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32m==> Looking for suitable agents in the library...\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Programmer', 'Mathematician'] are selected.\n", + "\u001b[32m==> Creating agents...\u001b[0m\n", + "Creating agent Programmer...\n", + "Creating agent Mathematician...\n", + "Adding user console proxy...\n", + "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", + "\n", + "Find a recent paper about explainable AI on arxiv and find its potential applications in medical.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Computer_terminal\n", + "\u001b[0m\n", + "\u001b[33mComputer_terminal\u001b[0m (to chat_manager):\n", + "\n", + "There is no code from the last 1 message for me to execute. Group chat manager should let other participants to continue the conversation. If the group chat manager want to end the conversation, you should let other participant reply me only with \"TERMINATE\"\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Programmer\n", + "\u001b[0m\n", + "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", + "\n", + "To find a recent paper about explainable AI on arXiv, we can use the arXiv API to search for papers that match the query. However, since I cannot directly access external APIs, I suggest that one of us manually searches for the paper on the arXiv website using relevant search terms such as \"explainable AI\" and \"medical applications\". Once we find a suitable paper, we can discuss its potential applications in the medical field. \n", + "\n", + "Mathematician, would you like to perform the search, or shall I provide a Python script that could be used to perform the search programmatically?\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Mathematician\n", + "\u001b[0m\n", + "\u001b[33mMathematician\u001b[0m (to chat_manager):\n", + "\n", + "As a Mathematician, I can certainly appreciate the value of a programmatic approach to searching for academic papers. However, since I do not have direct access to execute code or APIs, I would suggest that you, as the Programmer, provide the Python script that could be used to perform the search on arXiv. Once we have identified a paper, I can then assist in discussing its potential applications in the medical field from a mathematical perspective.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Programmer\n", + "\u001b[0m\n", + "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", + "\n", + "Understood. I will provide a Python script that can be used to search for recent papers about explainable AI on arXiv with potential applications in the medical field. The script will use the `arxiv` Python package, which is a wrapper for the arXiv API. If the package is not installed, we will need to install it first.\n", + "\n", + "Let's start by checking if the `arxiv` package is installed and if not, we will install it. Computer_terminal, please execute the following command to check for the `arxiv` package and install it if necessary.\n", + "\n", + "```sh\n", + "pip show arxiv || pip install arxiv\n", + "```\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Computer_terminal\n", + "\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is sh)...\u001b[0m\n", + "\u001b[33mComputer_terminal\u001b[0m (to chat_manager):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "Name: arxiv\n", + "Version: 2.1.0\n", + "Summary: Python wrapper for the arXiv API: https://arxiv.org/help/api/\n", + "Home-page: https://github.com/lukasschwab/arxiv.py\n", + "Author: Lukas Schwab\n", + "Author-email: lukas.schwab@gmail.com\n", + "License: MIT\n", + "Location: /home/vscode/.local/lib/python3.10/site-packages\n", + "Requires: feedparser, requests\n", + "Required-by: \n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Programmer\n", + "\u001b[0m\n", + "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", + "\n", + "Great, the `arxiv` package is already installed. Now, I will provide a Python script that uses the `arxiv` package to search for recent papers related to explainable AI with potential applications in the medical field. The script will query the arXiv API for papers with relevant keywords and print out the title and summary of the most recent paper found.\n", + "\n", + "Computer_terminal, please execute the following Python script.\n", + "\n", + "```python\n", + "import arxiv\n", + "\n", + "# Define the search query\n", + "search_query = 'all:explainable AI AND all:medical'\n", + "\n", + "# Search for papers on arXiv\n", + "search = arxiv.Search(\n", + " query = search_query,\n", + " max_results = 1,\n", + " sort_by = arxiv.SortCriterion.SubmittedDate\n", + ")\n", + "\n", + "# Fetch the most recent paper\n", + "for paper in search.results():\n", + " print(\"Title:\", paper.title)\n", + " print(\"Summary:\", paper.summary)\n", + " # Only print the most recent paper\n", + " break\n", + "```\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Computer_terminal\n", + "\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33mComputer_terminal\u001b[0m (to chat_manager):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "Title: Automated Information Extraction from Thyroid Operation Narrative: A Comparative Study of GPT-4 and Fine-tuned KoELECTRA\n", + "Summary: In the rapidly evolving field of healthcare, the integration of artificial\n", + "intelligence (AI) has become a pivotal component in the automation of clinical\n", + "workflows, ushering in a new era of efficiency and accuracy. This study focuses\n", + "on the transformative capabilities of the fine-tuned KoELECTRA model in\n", + "comparison to the GPT-4 model, aiming to facilitate automated information\n", + "extraction from thyroid operation narratives. The current research landscape is\n", + "dominated by traditional methods heavily reliant on regular expressions, which\n", + "often face challenges in processing free-style text formats containing critical\n", + "details of operation records, including frozen biopsy reports. Addressing this,\n", + "the study leverages advanced natural language processing (NLP) techniques to\n", + "foster a paradigm shift towards more sophisticated data processing systems.\n", + "Through this comparative study, we aspire to unveil a more streamlined,\n", + "precise, and efficient approach to document processing in the healthcare\n", + "domain, potentially revolutionizing the way medical data is handled and\n", + "analyzed.\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Mathematician\n", + "\u001b[0m\n", + "\u001b[33mMathematician\u001b[0m (to chat_manager):\n", + "\n", + "The paper titled \"Automated Information Extraction from Thyroid Operation Narrative: A Comparative Study of GPT-4 and Fine-tuned KoELECTRA\" presents a study on the use of artificial intelligence for automating the extraction of information from thyroid operation narratives. This is a clear example of explainable AI being applied in the medical field, specifically in the area of clinical workflows and document processing.\n", + "\n", + "The potential applications of such technology in medicine are vast. By automating the extraction of information from operation narratives, healthcare professionals can save time and reduce the likelihood of human error. This can lead to more accurate patient records, improved patient care, and streamlined administrative processes. Additionally, the ability to quickly and accurately process operation records can facilitate better data analysis, which can be used for medical research, trend analysis, and improving healthcare outcomes.\n", + "\n", + "The use of advanced natural language processing (NLP) techniques, as mentioned in the summary, is particularly important for processing free-style text formats that contain critical medical information. This technology could be further explored to extend its application to other types of medical documents and records, enhancing the overall efficiency of the healthcare system.\n", + "\n", + "The study's focus on comparing the performance of the fine-tuned KoELECTRA model with GPT-4 also highlights the importance of evaluating different AI models to determine the most effective approach for specific medical applications. This comparative analysis can lead to the development of more specialized AI tools tailored to the needs of the healthcare industry.\n", + "\n", + "In conclusion, the research presented in this paper has significant implications for the future of medical document processing and the broader integration of AI in healthcare.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Programmer\n", + "\u001b[0m\n", + "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", + "\n", + "The insights provided by the Mathematician are indeed valuable. The application of AI for automated information extraction from medical documents like thyroid operation narratives can greatly enhance efficiency and accuracy in healthcare. The use of models like GPT-4 and KoELECTRA for natural language processing tasks shows the potential of AI to handle complex, unstructured data which is common in medical records.\n", + "\n", + "From a programming perspective, the implementation of such AI systems would involve training models on large datasets of medical documents to learn the context and semantics specific to medical terminology. Ensuring the explainability of AI in this context is crucial, as healthcare professionals need to understand and trust the AI's decision-making process, especially when it directly affects patient care.\n", + "\n", + "Moreover, the integration of explainable AI into healthcare systems must adhere to strict privacy and security regulations to protect sensitive patient data. This requires careful design and implementation of data handling procedures within the AI system.\n", + "\n", + "The potential applications extend beyond just document processing to diagnostic assistance, personalized treatment plans, and predictive analytics for patient outcomes. As AI technology continues to evolve, its role in supporting and enhancing the capabilities of healthcare professionals will undoubtedly expand.\n", + "\n", + "Given the importance of the topic and the potential impact on healthcare, it would be beneficial to keep an eye on further developments in this field. If there are no further questions or points to discuss, we can conclude our conversation on this topic.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Mathematician\n", + "\u001b[0m\n", + "\u001b[33mMathematician\u001b[0m (to chat_manager):\n", + "\n", + "I agree with the Programmer's assessment. The implementation of AI in healthcare does indeed require careful consideration of the models used, the training data, and the explainability of the AI's decisions. The ethical implications, particularly concerning patient privacy and data security, are paramount and must be addressed with the utmost rigor.\n", + "\n", + "The potential for AI to assist in diagnostics, treatment planning, and predictive analytics is a promising development for the future of medicine. It is essential that these systems are developed in collaboration with healthcare professionals to ensure they meet the real-world needs of the field.\n", + "\n", + "The interdisciplinary nature of this work, combining expertise in mathematics, computer science, and medicine, is a testament to the collaborative efforts needed to advance healthcare technology. It has been a pleasure discussing the potential applications of explainable AI in medicine with you.\n", + "\n", + "If there are no further points to add, I believe we have reached a natural conclusion to our conversation.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Computer_terminal\n", + "\u001b[0m\n", + "\u001b[33mComputer_terminal\u001b[0m (to chat_manager):\n", + "\n", + "There is no code from the last 1 message for me to execute. Group chat manager should let other participants to continue the conversation. If the group chat manager want to end the conversation, you should let other participant reply me only with \"TERMINATE\"\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mAll agents have been cleared.\u001b[0m\n" + ] + } + ], + "source": [ + "new_builder = AgentBuilder(\n", + " config_file_or_env=config_file_or_env, builder_model=\"gpt-4-1106-preview\", agent_model=\"gpt-4-1106-preview\"\n", + ")\n", + "agent_list, _ = new_builder.build_from_library(building_task, library_path_or_json, llm_config)\n", + "start_task(\n", + " execution_task=\"Find a recent paper about explainable AI on arxiv and find its potential applications in medical.\",\n", + " agent_list=agent_list,\n", + ")\n", + "new_builder.clear_all_agents()" + ] + }, + { + "cell_type": "markdown", + "id": "c7a10e6fa00a5a0d", + "metadata": { + "collapsed": false + }, + "source": [ + "## Build agents from library (by description-task similarity)\n", + "We also support using embedding similarity to select agents. You can use a [Sentence-Transformers model](https://www.sbert.net/docs/pretrained_models.html) as an embedding extractor, and AgentBuilder will select agents with profiles that are the most similar to the building task from the library by comparing their embedding similarity. This will reduce the use of LLMs but may have less accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "521dc5f961efde59", + "metadata": { + "ExecuteTime": { + "end_time": "2023-12-26T17:01:29.333975100Z", + "start_time": "2023-12-26T16:58:11.070813500Z" + }, + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32m==> Looking for suitable agents in the library...\u001b[0m\n" + ] }, - "nbformat": 4, - "nbformat_minor": 5 + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Programmer', 'Mathematician'] are selected.\n", + "\u001b[32m==> Creating agents...\u001b[0m\n", + "Creating agent Programmer...\n", + "Creating agent Mathematician...\n", + "Adding user console proxy...\n", + "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", + "\n", + "Find a recent paper about gpt-4 on arxiv and find its potential applications in software.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Computer_terminal\n", + "\u001b[0m\n", + "\u001b[33mComputer_terminal\u001b[0m (to chat_manager):\n", + "\n", + "There is no code from the last 1 message for me to execute. Group chat manager should let other participants to continue the conversation. If the group chat manager want to end the conversation, you should let other participant reply me only with \"TERMINATE\"\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Programmer\n", + "\u001b[0m\n", + "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", + "\n", + "To find a recent paper about GPT-4 on arXiv, we can use the arXiv API to search for papers. However, since I can't directly access external APIs, I can write a Python script that you can run on your local machine to perform this search. Would you like me to provide you with such a script?\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Computer_terminal\n", + "\u001b[0m\n", + "\u001b[33mComputer_terminal\u001b[0m (to chat_manager):\n", + "\n", + "There is no code from the last 1 message for me to execute. Group chat manager should let other participants to continue the conversation. If the group chat manager want to end the conversation, you should let other participant reply me only with \"TERMINATE\"\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Programmer\n", + "\u001b[0m\n", + "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", + "\n", + "I apologize for the confusion. I will provide a Python script that can be executed by the Computer_terminal to search for recent papers about GPT-4 on arXiv. Let's proceed with that.\n", + "\n", + "```python\n", + "import requests\n", + "from xml.etree import ElementTree\n", + "\n", + "# Define the search parameters and URL for the arXiv API\n", + "search_query = 'all:gpt-4'\n", + "start = 0\n", + "max_results = 5\n", + "sort_by = 'submittedDate'\n", + "sort_order = 'descending'\n", + "url = f'http://export.arxiv.org/api/query?search_query={search_query}&start={start}&max_results={max_results}&sortBy={sort_by}&sortOrder={sort_order}'\n", + "\n", + "# Send a GET request to the arXiv API\n", + "response = requests.get(url)\n", + "\n", + "# Parse the response if it was successful\n", + "if response.status_code == 200:\n", + " root = ElementTree.fromstring(response.content)\n", + " # Find and print the entries (papers)\n", + " for entry in root.findall('{http://www.w3.org/2005/Atom}entry'):\n", + " title = entry.find('{http://www.w3.org/2005/Atom}title').text\n", + " summary = entry.find('{http://www.w3.org/2005/Atom}summary').text\n", + " published = entry.find('{http://www.w3.org/2005/Atom}published').text\n", + " print(f\"Title: {title}\\nSummary: {summary}\\nPublished Date: {published}\\n\")\n", + "else:\n", + " print(f\"Failed to fetch data from arXiv. Status code: {response.status_code}\")\n", + "```\n", + "\n", + "This script will fetch the most recent papers related to GPT-4 from the arXiv API and print out their titles, summaries, and publication dates. Please execute this script to find the information we need.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Computer_terminal\n", + "\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33mComputer_terminal\u001b[0m (to chat_manager):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "Title: What If We Recaption Billions of Web Images with LLaMA-3?\n", + "Summary: Web-crawled image-text pairs are inherently noisy. Prior studies demonstrate\n", + "that semantically aligning and enriching textual descriptions of these pairs\n", + "can significantly enhance model training across various vision-language tasks,\n", + "particularly text-to-image generation. However, large-scale investigations in\n", + "this area remain predominantly closed-source. Our paper aims to bridge this\n", + "community effort, leveraging the powerful and \\textit{open-sourced} LLaMA-3, a\n", + "GPT-4 level LLM. Our recaptioning pipeline is simple: first, we fine-tune a\n", + "LLaMA-3-8B powered LLaVA-1.5 and then employ it to recaption 1.3 billion images\n", + "from the DataComp-1B dataset. Our empirical results confirm that this enhanced\n", + "dataset, Recap-DataComp-1B, offers substantial benefits in training advanced\n", + "vision-language models. For discriminative models like CLIP, we observe\n", + "enhanced zero-shot performance in cross-modal retrieval tasks. For generative\n", + "models like text-to-image Diffusion Transformers, the generated images exhibit\n", + "a significant improvement in alignment with users' text instructions,\n", + "especially in following complex queries. Our project page is\n", + "https://www.haqtu.me/Recap-Datacomp-1B/\n", + "\n", + "Published Date: 2024-06-12T17:59:07Z\n", + "\n", + "Title: DafnyBench: A Benchmark for Formal Software Verification\n", + "Summary: We introduce DafnyBench, the largest benchmark of its kind for training and\n", + "evaluating machine learning systems for formal software verification. We test\n", + "the ability of LLMs such as GPT-4 and Claude 3 to auto-generate enough hints\n", + "for the Dafny formal verification engine to successfully verify over 750\n", + "programs with about 53,000 lines of code. The best model and prompting scheme\n", + "achieved 68% success rate, and we quantify how this rate improves when retrying\n", + "with error message feedback and how it deteriorates with the amount of required\n", + "code and hints. We hope that DafnyBench will enable rapid improvements from\n", + "this baseline as LLMs and verification techniques grow in quality.\n", + "\n", + "Published Date: 2024-06-12T17:53:31Z\n", + "\n", + "Title: A Sociotechnical Lens for Evaluating Computer Vision Models: A Case\n", + " Study on Detecting and Reasoning about Gender and Emotion\n", + "Summary: In the evolving landscape of computer vision (CV) technologies, the automatic\n", + "detection and interpretation of gender and emotion in images is a critical area\n", + "of study. This paper investigates social biases in CV models, emphasizing the\n", + "limitations of traditional evaluation metrics such as precision, recall, and\n", + "accuracy. These metrics often fall short in capturing the complexities of\n", + "gender and emotion, which are fluid and culturally nuanced constructs. Our\n", + "study proposes a sociotechnical framework for evaluating CV models,\n", + "incorporating both technical performance measures and considerations of social\n", + "fairness. Using a dataset of 5,570 images related to vaccination and climate\n", + "change, we empirically compared the performance of various CV models, including\n", + "traditional models like DeepFace and FER, and generative models like GPT-4\n", + "Vision. Our analysis involved manually validating the gender and emotional\n", + "expressions in a subset of images to serve as benchmarks. Our findings reveal\n", + "that while GPT-4 Vision outperforms other models in technical accuracy for\n", + "gender classification, it exhibits discriminatory biases, particularly in\n", + "response to transgender and non-binary personas. Furthermore, the model's\n", + "emotion detection skew heavily towards positive emotions, with a notable bias\n", + "towards associating female images with happiness, especially when prompted by\n", + "male personas. These findings underscore the necessity of developing more\n", + "comprehensive evaluation criteria that address both validity and discriminatory\n", + "biases in CV models. Our proposed framework provides guidelines for researchers\n", + "to critically assess CV tools, ensuring their application in communication\n", + "research is both ethical and effective. The significant contribution of this\n", + "study lies in its emphasis on a sociotechnical approach, advocating for CV\n", + "technologies that support social good and mitigate biases rather than\n", + "perpetuate them.\n", + "\n", + "Published Date: 2024-06-12T13:52:30Z\n", + "\n", + "Title: Supportiveness-based Knowledge Rewriting for Retrieval-augmented\n", + " Language Modeling\n", + "Summary: Retrieval-augmented language models (RALMs) have recently shown great\n", + "potential in mitigating the limitations of implicit knowledge in LLMs, such as\n", + "untimely updating of the latest expertise and unreliable retention of long-tail\n", + "knowledge. However, since the external knowledge base, as well as the\n", + "retriever, can not guarantee reliability, potentially leading to the knowledge\n", + "retrieved not being helpful or even misleading for LLM generation. In this\n", + "paper, we introduce Supportiveness-based Knowledge Rewriting (SKR), a robust\n", + "and pluggable knowledge rewriter inherently optimized for LLM generation.\n", + "Specifically, we introduce the novel concept of \"supportiveness\"--which\n", + "represents how effectively a knowledge piece facilitates downstream tasks--by\n", + "considering the perplexity impact of augmented knowledge on the response text\n", + "of a white-box LLM. Based on knowledge supportiveness, we first design a\n", + "training data curation strategy for our rewriter model, effectively identifying\n", + "and filtering out poor or irrelevant rewrites (e.g., with low supportiveness\n", + "scores) to improve data efficacy. We then introduce the direct preference\n", + "optimization (DPO) algorithm to align the generated rewrites to optimal\n", + "supportiveness, guiding the rewriter model to summarize augmented content that\n", + "better improves the final response. Comprehensive evaluations across six\n", + "popular knowledge-intensive tasks and four LLMs have demonstrated the\n", + "effectiveness and superiority of SKR. With only 7B parameters, SKR has shown\n", + "better knowledge rewriting capability over GPT-4, the current state-of-the-art\n", + "general-purpose LLM.\n", + "\n", + "Published Date: 2024-06-12T11:52:35Z\n", + "\n", + "Title: Automated Information Extraction from Thyroid Operation Narrative: A\n", + " Comparative Study of GPT-4 and Fine-tuned KoELECTRA\n", + "Summary: In the rapidly evolving field of healthcare, the integration of artificial\n", + "intelligence (AI) has become a pivotal component in the automation of clinical\n", + "workflows, ushering in a new era of efficiency and accuracy. This study focuses\n", + "on the transformative capabilities of the fine-tuned KoELECTRA model in\n", + "comparison to the GPT-4 model, aiming to facilitate automated information\n", + "extraction from thyroid operation narratives. The current research landscape is\n", + "dominated by traditional methods heavily reliant on regular expressions, which\n", + "often face challenges in processing free-style text formats containing critical\n", + "details of operation records, including frozen biopsy reports. Addressing this,\n", + "the study leverages advanced natural language processing (NLP) techniques to\n", + "foster a paradigm shift towards more sophisticated data processing systems.\n", + "Through this comparative study, we aspire to unveil a more streamlined,\n", + "precise, and efficient approach to document processing in the healthcare\n", + "domain, potentially revolutionizing the way medical data is handled and\n", + "analyzed.\n", + "\n", + "Published Date: 2024-06-12T06:44:05Z\n", + "\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Programmer\n", + "\u001b[0m\n", + "\u001b[33mProgrammer\u001b[0m (to chat_manager):\n", + "\n", + "Based on the search results from the arXiv API, we have found several papers that discuss potential applications of GPT-4 in software:\n", + "\n", + "1. **Recaptioning Web Images with LLaMA-3 and GPT-4**: This paper discusses the use of GPT-4 level LLMs for recaptioning web images, which can enhance model training across various vision-language tasks. This has implications for improving the quality of datasets used in machine learning and could be particularly beneficial for text-to-image generation and cross-modal retrieval tasks.\n", + "\n", + "2. **DafnyBench: A Benchmark for Formal Software Verification**: This paper introduces a benchmark for training and evaluating machine learning systems for formal software verification. It tests the ability of LLMs such as GPT-4 to auto-generate hints for the Dafny formal verification engine to successfully verify programs. This application could significantly impact the field of software verification by automating the generation of verification hints, potentially improving the efficiency and reliability of the verification process.\n", + "\n", + "3. **Automated Information Extraction from Thyroid Operation Narrative**: This study compares the GPT-4 model with the fine-tuned KoELECTRA model for automated information extraction from thyroid operation narratives. The application of GPT-4 in this context could revolutionize document processing in healthcare by providing a more efficient and accurate method for extracting information from medical records.\n", + "\n", + "These papers suggest that GPT-4 has the potential to be applied in various software-related fields, including enhancing datasets for machine learning, formal software verification, and healthcare document processing. The applications in these papers could lead to more efficient, accurate, and reliable software systems across different domains.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Mathematician\n", + "\u001b[0m\n", + "\u001b[33mMathematician\u001b[0m (to chat_manager):\n", + "\n", + "The applications mentioned indeed highlight the versatility of GPT-4 in different domains. To further understand the potential impact of GPT-4 on software, let's delve into the mathematical and algorithmic principles that could be at play in these applications:\n", + "\n", + "1. **Recaptioning Web Images**: The process of recaptioning images with a language model like GPT-4 involves understanding the context of an image and generating descriptive text that accurately reflects its content. This task likely involves a combination of computer vision techniques to interpret the image and natural language processing to generate the caption. From a mathematical perspective, this would involve optimization algorithms to fine-tune the language model on a specific dataset, ensuring that the generated captions are both semantically and syntactically correct.\n", + "\n", + "2. **Formal Software Verification**: The use of GPT-4 to auto-generate hints for formal verification engines like Dafny involves the model understanding the logic and structure of the code. This requires a deep understanding of formal logic, proof theory, and possibly type theory if the language being verified is statically typed. The success rate of auto-generated hints would depend on the model's ability to reason about the correctness of code and the underlying mathematical properties that ensure its validity.\n", + "\n", + "3. **Automated Information Extraction from Medical Records**: For GPT-4 to extract information from medical narratives, it must process unstructured text and identify relevant medical terms and their relationships. This task involves natural language understanding, which from a mathematical standpoint, can be seen as a form of pattern recognition and classification. The model would need to be trained on a large corpus of medical texts, and its performance would be measured by its precision and recall in identifying and extracting the correct information.\n", + "\n", + "In each of these applications, GPT-4's effectiveness would be influenced by the underlying mathematical models, such as neural networks, and the optimization techniques used during training, such as gradient descent. The quality of the training data and the model's architecture (e.g., attention mechanisms, transformer layers) also play a crucial role in its performance.\n", + "\n", + "To verify the potential of GPT-4 in these applications, one could set up experiments to measure the performance of GPT-4 against specific benchmarks or metrics relevant to each domain. For example, in the case of formal software verification, one could measure the percentage of programs that are successfully verified with the hints generated by GPT-4 compared to a baseline or human-generated hints.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Mathematician\n", + "\u001b[0m\n", + "\u001b[33mMathematician\u001b[0m (to chat_manager):\n", + "\n", + "To further verify the potential applications of GPT-4 in software, we can consider the following:\n", + "\n", + "1. **Recaptioning Web Images**: The effectiveness of GPT-4 in this application can be measured by the accuracy of the captions it generates. This can be quantified using metrics such as BLEU (Bilingual Evaluation Understudy) or ROUGE (Recall-Oriented Understudy for Gisting Evaluation), which compare the machine-generated text to a set of reference captions. A high score on these metrics would indicate that GPT-4 is capable of understanding and describing the content of images accurately.\n", + "\n", + "2. **Formal Software Verification**: To verify the application of GPT-4 in software verification, we could measure the success rate of the model in generating verification hints that lead to successful program verification. This could be done by comparing the verification success rate with and without the hints provided by GPT-4. Additionally, the complexity of the programs and the hints required could be analyzed to understand the model's limitations and strengths.\n", + "\n", + "3. **Automated Information Extraction from Medical Records**: The performance of GPT-4 in extracting information from medical narratives can be assessed by comparing the extracted information to a gold standard set of annotations. Precision, recall, and F1-score are common metrics used to evaluate information extraction systems. A high F1-score would suggest that GPT-4 is effective in identifying and extracting relevant information from unstructured medical texts.\n", + "\n", + "For each of these applications, it would be important to conduct a thorough analysis of the results to ensure that the model's performance is not only statistically significant but also practically relevant. Additionally, it would be crucial to assess the model's performance on diverse datasets to ensure that it generalizes well across different contexts and does not exhibit biases that could lead to incorrect or unfair outcomes.\n", + "\n", + "If we want to simulate or test these applications, we could propose specific experiments or data analysis procedures that align with the above verification strategies. However, such experiments would require access to the relevant datasets and computational resources to run the models, which may not be feasible within the scope of this conversation.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Mathematician\n", + "\u001b[0m\n", + "\u001b[33mMathematician\u001b[0m (to chat_manager):\n", + "\n", + "To simulate or test these applications, we could propose specific experiments or data analysis procedures that align with the above verification strategies. However, such experiments would require access to the relevant datasets and computational resources to run the models, which may not be feasible within the scope of this conversation.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[32m\n", + "Next speaker: Mathematician\n", + "\u001b[0m\n", + "\u001b[33mMathematician\u001b[0m (to chat_manager):\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mAll agents have been cleared.\u001b[0m\n" + ] + } + ], + "source": [ + "new_builder = AgentBuilder(\n", + " config_file_or_env=config_file_or_env, builder_model=\"gpt-4-1106-preview\", agent_model=\"gpt-4-1106-preview\"\n", + ")\n", + "agent_list, _ = new_builder.build_from_library(\n", + " building_task, library_path_or_json, llm_config, embedding_model=\"all-mpnet-base-v2\"\n", + ")\n", + "start_task(\n", + " execution_task=\"Find a recent paper about gpt-4 on arxiv and find its potential applications in software.\",\n", + " agent_list=agent_list,\n", + ")\n", + "new_builder.clear_all_agents()" + ] + } + ], + "metadata": { + "front_matter": { + "description": "Automatically build multi-agent system from agent library", + "tags": [ + "autobuild" + ] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 } diff --git a/notebook/tools_crewai_tools_integration.ipynb b/notebook/tools_crewai_tools_integration.ipynb index 78b85cbccc..beaf7ec298 100644 --- a/notebook/tools_crewai_tools_integration.ipynb +++ b/notebook/tools_crewai_tools_integration.ipynb @@ -189,7 +189,7 @@ "\"\"\"\n", " user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)\n", "\n", - " assert Path(tmpdirname, filename).read_text() == \"Easy Migration :)\"\n" + " assert Path(tmpdirname, filename).read_text() == \"Easy Migration :)\"" ] }, { diff --git a/notebook/tools_langchain_tools_integration.ipynb b/notebook/tools_langchain_tools_integration.ipynb new file mode 100644 index 0000000000..4aa42d15fe --- /dev/null +++ b/notebook/tools_langchain_tools_integration.ipynb @@ -0,0 +1,152 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ! pip install wikipedia" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "from langchain_community.tools import WikipediaQueryRun\n", + "from langchain_community.utilities import WikipediaAPIWrapper\n", + "\n", + "from autogen import AssistantAgent, UserProxyAgent\n", + "from autogen.interoperability.langchain import LangchainInteroperability" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "config_list = [{\"model\": \"gpt-4o\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", + "user_proxy = UserProxyAgent(\n", + " name=\"User\",\n", + " human_input_mode=\"NEVER\",\n", + ")\n", + "\n", + "chatbot = AssistantAgent(\n", + " name=\"chatbot\",\n", + " llm_config={\"config_list\": config_list},\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=1000)\n", + "langchain_tool = WikipediaQueryRun(api_wrapper=api_wrapper)\n", + "\n", + "langchain_interop = LangchainInteroperability()\n", + "ag2_tool = langchain_interop.convert_tool(langchain_tool)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "ag2_tool.register_for_execution(user_proxy)\n", + "ag2_tool.register_for_llm(chatbot)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mUser\u001b[0m (to chatbot):\n", + "\n", + "Tell me about the history of the United States\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mchatbot\u001b[0m (to User):\n", + "\n", + "\u001b[32m***** Suggested tool call (call_gBcszkAyMnQ5z1InEf4aEUmn): wikipedia *****\u001b[0m\n", + "Arguments: \n", + "{\"tool_input\":{\"query\":\"History of the United States\"}}\n", + "\u001b[32m**************************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION wikipedia...\u001b[0m\n", + "\u001b[33mUser\u001b[0m (to chatbot):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_gBcszkAyMnQ5z1InEf4aEUmn) *****\u001b[0m\n", + "Page: History of the United States\n", + "Summary: The history of the lands that became the United States began with the arrival of the first people in the Americas around 15,000 BC. After European colonization of North America began in the late 15th century, wars and epidemics decimated Indigenous societies. By the 1760s, the thirteen British colonies were established. The Southern Colonies built an agricultural system on slave labor, enslaving millions from Africa. After defeating France, the British Parliament imposed a series of taxes; resistance to these taxes, especially the Boston Tea Party in 1773, led to Parliament issuing the Intolerable Acts designed to end self-government.\n", + "In 1776, the United States declared its independence. Led by General George Washington, it won the Revolutionary War in 1783. The Constitution was adopted in 1789, and a Bill of Rights was added in 1791 to guarantee inalienable rights. George Washington, the first president, and his adviser Alexander Hamilton cr\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mchatbot\u001b[0m (to User):\n", + "\n", + "The history of the United States began with the arrival of Native Americans in North America around 15,000 BC. European colonization of North America started in the late 15th century, which severely affected Indigenous societies through wars and epidemics.\n", + "\n", + "By the 1760s, thirteen British colonies had been established. The Southern Colonies developed an economy heavily reliant on slave labor, enslaving millions of people brought from Africa. The British victory over France led to increased British taxation of the colonies, leading to resistance from the colonists, exemplified by events like the Boston Tea Party in 1773.\n", + "\n", + "The growing tensions resulted in the American colonies declaring independence in 1776. With General George Washington leading the Continental Army, the United States won the Revolutionary War against Britain in 1783. The U.S. Constitution was adopted in 1789, establishing the foundation of the federal government, and the Bill of Rights was added in 1791 to ensure individual liberties. George Washington became the nation’s first president, with Alexander Hamilton among his key advisers.\n", + "\n", + "This marks the early formation and foundation of the United States as an independent nation. If you need more detailed information, let me know! TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "data": { + "text/plain": [ + "ChatResult(chat_id=None, chat_history=[{'content': 'Tell me about the history of the United States', 'role': 'assistant', 'name': 'User'}, {'tool_calls': [{'id': 'call_gBcszkAyMnQ5z1InEf4aEUmn', 'function': {'arguments': '{\"tool_input\":{\"query\":\"History of the United States\"}}', 'name': 'wikipedia'}, 'type': 'function'}], 'content': None, 'role': 'assistant'}, {'content': 'Page: History of the United States\\nSummary: The history of the lands that became the United States began with the arrival of the first people in the Americas around 15,000 BC. After European colonization of North America began in the late 15th century, wars and epidemics decimated Indigenous societies. By the 1760s, the thirteen British colonies were established. The Southern Colonies built an agricultural system on slave labor, enslaving millions from Africa. After defeating France, the British Parliament imposed a series of taxes; resistance to these taxes, especially the Boston Tea Party in 1773, led to Parliament issuing the Intolerable Acts designed to end self-government.\\nIn 1776, the United States declared its independence. Led by General George Washington, it won the Revolutionary War in 1783. The Constitution was adopted in 1789, and a Bill of Rights was added in 1791 to guarantee inalienable rights. George Washington, the first president, and his adviser Alexander Hamilton cr', 'tool_responses': [{'tool_call_id': 'call_gBcszkAyMnQ5z1InEf4aEUmn', 'role': 'tool', 'content': 'Page: History of the United States\\nSummary: The history of the lands that became the United States began with the arrival of the first people in the Americas around 15,000 BC. After European colonization of North America began in the late 15th century, wars and epidemics decimated Indigenous societies. By the 1760s, the thirteen British colonies were established. The Southern Colonies built an agricultural system on slave labor, enslaving millions from Africa. After defeating France, the British Parliament imposed a series of taxes; resistance to these taxes, especially the Boston Tea Party in 1773, led to Parliament issuing the Intolerable Acts designed to end self-government.\\nIn 1776, the United States declared its independence. Led by General George Washington, it won the Revolutionary War in 1783. The Constitution was adopted in 1789, and a Bill of Rights was added in 1791 to guarantee inalienable rights. George Washington, the first president, and his adviser Alexander Hamilton cr'}], 'role': 'tool', 'name': 'User'}, {'content': 'The history of the United States began with the arrival of Native Americans in North America around 15,000 BC. European colonization of North America started in the late 15th century, which severely affected Indigenous societies through wars and epidemics.\\n\\nBy the 1760s, thirteen British colonies had been established. The Southern Colonies developed an economy heavily reliant on slave labor, enslaving millions of people brought from Africa. The British victory over France led to increased British taxation of the colonies, leading to resistance from the colonists, exemplified by events like the Boston Tea Party in 1773.\\n\\nThe growing tensions resulted in the American colonies declaring independence in 1776. With General George Washington leading the Continental Army, the United States won the Revolutionary War against Britain in 1783. The U.S. Constitution was adopted in 1789, establishing the foundation of the federal government, and the Bill of Rights was added in 1791 to ensure individual liberties. George Washington became the nation’s first president, with Alexander Hamilton among his key advisers.\\n\\nThis marks the early formation and foundation of the United States as an independent nation. If you need more detailed information, let me know! TERMINATE', 'role': 'user', 'name': 'chatbot'}], summary='The history of the United States began with the arrival of Native Americans in North America around 15,000 BC. European colonization of North America started in the late 15th century, which severely affected Indigenous societies through wars and epidemics.\\n\\nBy the 1760s, thirteen British colonies had been established. The Southern Colonies developed an economy heavily reliant on slave labor, enslaving millions of people brought from Africa. The British victory over France led to increased British taxation of the colonies, leading to resistance from the colonists, exemplified by events like the Boston Tea Party in 1773.\\n\\nThe growing tensions resulted in the American colonies declaring independence in 1776. With General George Washington leading the Continental Army, the United States won the Revolutionary War against Britain in 1783. The U.S. Constitution was adopted in 1789, establishing the foundation of the federal government, and the Bill of Rights was added in 1791 to ensure individual liberties. George Washington became the nation’s first president, with Alexander Hamilton among his key advisers.\\n\\nThis marks the early formation and foundation of the United States as an independent nation. If you need more detailed information, let me know! ', cost={'usage_including_cached_inference': {'total_cost': 0.00601, 'gpt-4o-2024-08-06': {'cost': 0.00601, 'prompt_tokens': 1356, 'completion_tokens': 262, 'total_tokens': 1618}}, 'usage_excluding_cached_inference': {'total_cost': 0}}, human_input=[])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "message = \"Tell me about the history of the United States\"\n", + "user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/setup.py b/setup.py index e2eba94b05..7e002036f6 100644 --- a/setup.py +++ b/setup.py @@ -123,6 +123,7 @@ "ollama": ["ollama>=0.3.3", "fix_busted_json>=0.0.18"], "bedrock": ["boto3>=1.34.149"], "interop-crewai": ["crewai[tools]>=0.86,<1; python_version>='3.10' and python_version<'3.13'"], + "interop-langchain": ["langchain-community>=0.3.12"], "neo4j": neo4j, } diff --git a/test/interoperability/crewai/test_crewai.py b/test/interoperability/crewai/test_crewai.py index f563116a83..2f8235e9fb 100644 --- a/test/interoperability/crewai/test_crewai.py +++ b/test/interoperability/crewai/test_crewai.py @@ -61,7 +61,7 @@ def test_convert_tool(self) -> None: @pytest.mark.skipif(skip_openai, reason=reason) def test_with_llm(self) -> None: - config_list = [{"model": "gpt-4", "api_key": os.environ["OPENAI_API_KEY"]}] + config_list = [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}] user_proxy = UserProxyAgent( name="User", human_input_mode="NEVER", diff --git a/test/interoperability/langchain/__init__.py b/test/interoperability/langchain/__init__.py new file mode 100644 index 0000000000..bcd5401d54 --- /dev/null +++ b/test/interoperability/langchain/__init__.py @@ -0,0 +1,3 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/test/interoperability/langchain/test_langchain.py b/test/interoperability/langchain/test_langchain.py new file mode 100644 index 0000000000..014d5ebe21 --- /dev/null +++ b/test/interoperability/langchain/test_langchain.py @@ -0,0 +1,71 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +import os + +import pytest +from conftest import reason, skip_openai +from langchain.tools import tool +from pydantic import BaseModel, Field + +from autogen import AssistantAgent, UserProxyAgent +from autogen.interoperability import Interoperable +from autogen.interoperability.langchain import LangchainInteroperability + + +class TestLangchainInteroperability: + @pytest.fixture(autouse=True) + def setup(self) -> None: + class SearchInput(BaseModel): + query: str = Field(description="should be a search query") + + @tool("search-tool", args_schema=SearchInput, return_direct=True) # type: ignore[misc] + def search(query: SearchInput) -> str: + """Look up things online.""" + return "LangChain Integration" + + self.langchain_interop = LangchainInteroperability() + self.model_type = search.args_schema + self.tool = self.langchain_interop.convert_tool(search) + + def test_type_checks(self) -> None: + # mypy should fail if the type checks are not correct + interop: Interoperable = self.langchain_interop + # runtime check + assert isinstance(interop, Interoperable) + + def test_init(self) -> None: + assert isinstance(self.langchain_interop, Interoperable) + + def test_convert_tool(self) -> None: + assert self.tool.name == "search-tool" + assert self.tool.description == "Look up things online." + + tool_input = self.model_type(query="LangChain") + assert self.tool.func(tool_input=tool_input) == "LangChain Integration" + + @pytest.mark.skipif(skip_openai, reason=reason) + def test_with_llm(self) -> None: + config_list = [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}] + user_proxy = UserProxyAgent( + name="User", + human_input_mode="NEVER", + ) + + chatbot = AssistantAgent( + name="chatbot", + llm_config={"config_list": config_list}, + ) + + self.tool.register_for_execution(user_proxy) + self.tool.register_for_llm(chatbot) + + user_proxy.initiate_chat(recipient=chatbot, message="search for LangChain", max_turns=2) + + for message in user_proxy.chat_messages[chatbot]: + if "tool_responses" in message: + assert message["tool_responses"][0]["content"] == "LangChain Integration" + return + + assert False, "No tool response found in chat messages" From 4a304326aba81bcbf9187bf78e638195c2a3acd3 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Mon, 16 Dec 2024 15:29:46 +0100 Subject: [PATCH 22/70] Update LangchainInteroperability tests --- .../langchain/test_langchain.py | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+) diff --git a/test/interoperability/langchain/test_langchain.py b/test/interoperability/langchain/test_langchain.py index 014d5ebe21..981f60ed8d 100644 --- a/test/interoperability/langchain/test_langchain.py +++ b/test/interoperability/langchain/test_langchain.py @@ -69,3 +69,48 @@ def test_with_llm(self) -> None: return assert False, "No tool response found in chat messages" + + +class TestLangchainInteroperabilityWithoutPydanticInput: + @pytest.fixture(autouse=True) + def setup(self) -> None: + @tool # type: ignore[misc] + def search(query: str, max_length: int) -> str: + """Look up things online.""" + return f"LangChain Integration, max_length: {max_length}" + + self.langchain_interop = LangchainInteroperability() + self.tool = self.langchain_interop.convert_tool(search) + self.model_type = search.args_schema + + def test_convert_tool(self) -> None: + assert self.tool.name == "search" + assert self.tool.description == "Look up things online." + + tool_input = self.model_type(query="LangChain", max_length=100) + assert self.tool.func(tool_input=tool_input) == "LangChain Integration, max_length: 100" + + @pytest.mark.skipif(skip_openai, reason=reason) + def test_with_llm(self) -> None: + config_list = [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}] + user_proxy = UserProxyAgent( + name="User", + human_input_mode="NEVER", + ) + + chatbot = AssistantAgent( + name="chatbot", + llm_config={"config_list": config_list}, + ) + + self.tool.register_for_execution(user_proxy) + self.tool.register_for_llm(chatbot) + + user_proxy.initiate_chat(recipient=chatbot, message="search for LangChain, Use max 100 characters", max_turns=2) + + for message in user_proxy.chat_messages[chatbot]: + if "tool_responses" in message: + assert message["tool_responses"][0]["content"] == "LangChain Integration, max_length: 100" + return + + assert False, "No tool response found in chat messages" From 3eefd224271de9ef5026bb87998f3ca9e74129ea Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Mon, 16 Dec 2024 15:32:20 +0100 Subject: [PATCH 23/70] Update setup*.py files with interop-langchain --- setup_ag2.py | 1 + setup_autogen.py | 1 + 2 files changed, 2 insertions(+) diff --git a/setup_ag2.py b/setup_ag2.py index f1653a958f..bd7077b182 100644 --- a/setup_ag2.py +++ b/setup_ag2.py @@ -55,6 +55,7 @@ "ollama": ["pyautogen[ollama]==" + __version__], "bedrock": ["pyautogen[bedrock]==" + __version__], "interop-crewai": ["pyautogen[interop-crewai]==" + __version__], + "interop-langchain": ["pyautogen[interop-langchain]==" + __version__], "neo4j": ["pyautogen[neo4j]==" + __version__], }, url="https://github.com/ag2ai/ag2", diff --git a/setup_autogen.py b/setup_autogen.py index 274f3ec417..16f43b4284 100644 --- a/setup_autogen.py +++ b/setup_autogen.py @@ -55,6 +55,7 @@ "ollama": ["pyautogen[ollama]==" + __version__], "bedrock": ["pyautogen[bedrock]==" + __version__], "interop-crewai": ["pyautogen[interop-crewai]==" + __version__], + "interop-langchain": ["pyautogen[interop-langchain]==" + __version__], "neo4j": ["pyautogen[neo4j]==" + __version__], }, url="https://github.com/ag2ai/ag2", From a8010e028fa4c72959c4c97ba788bcc26f346af9 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Mon, 16 Dec 2024 15:50:43 +0100 Subject: [PATCH 24/70] Update CI for interop-langchain tests --- .github/workflows/build.yml | 2 +- .github/workflows/openai.yml | 2 +- autogen/interoperability/langchain/__init__.py | 5 +++++ setup.py | 2 +- .../interoperability/langchain/test_langchain.py | 16 +++++++++++++++- 5 files changed, 23 insertions(+), 4 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index a9ef7ea7aa..9cec9d24bb 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -71,7 +71,7 @@ jobs: - name: Install packages and dependencies run: | python -m pip install --upgrade pip wheel - pip install -e .[test,cosmosdb,interop-crewai] + pip install -e .[test,cosmosdb,interop-crewai,interop-langchain] python -c "import autogen" pip install pytest-cov>=5 mock - name: Install optional dependencies for code executors diff --git a/.github/workflows/openai.yml b/.github/workflows/openai.yml index 51417d5f6e..a536102e20 100644 --- a/.github/workflows/openai.yml +++ b/.github/workflows/openai.yml @@ -55,7 +55,7 @@ jobs: if: matrix.python-version == '3.9' run: | pip install docker - pip install -e .[redis,interop-crewai] + pip install -e .[redis,interop-crewai,interop-langchain] - name: Coverage if: matrix.python-version == '3.9' env: diff --git a/autogen/interoperability/langchain/__init__.py b/autogen/interoperability/langchain/__init__.py index bdae155fdd..233c8642c3 100644 --- a/autogen/interoperability/langchain/__init__.py +++ b/autogen/interoperability/langchain/__init__.py @@ -2,6 +2,11 @@ # # SPDX-License-Identifier: Apache-2.0 +import sys + +if sys.version_info < (3, 9): + raise ImportError("This submodule is only supported for Python versions 3.9 and above") + try: import langchain.tools except ImportError: diff --git a/setup.py b/setup.py index 7e002036f6..0c565817fd 100644 --- a/setup.py +++ b/setup.py @@ -123,7 +123,7 @@ "ollama": ["ollama>=0.3.3", "fix_busted_json>=0.0.18"], "bedrock": ["boto3>=1.34.149"], "interop-crewai": ["crewai[tools]>=0.86,<1; python_version>='3.10' and python_version<'3.13'"], - "interop-langchain": ["langchain-community>=0.3.12"], + "interop-langchain": ["langchain-community>=0.3.12,<1; python_version>='3.9'"], "neo4j": neo4j, } diff --git a/test/interoperability/langchain/test_langchain.py b/test/interoperability/langchain/test_langchain.py index 981f60ed8d..8ab346ff40 100644 --- a/test/interoperability/langchain/test_langchain.py +++ b/test/interoperability/langchain/test_langchain.py @@ -3,6 +3,8 @@ # SPDX-License-Identifier: Apache-2.0 import os +import sys +import unittest import pytest from conftest import reason, skip_openai @@ -11,9 +13,17 @@ from autogen import AssistantAgent, UserProxyAgent from autogen.interoperability import Interoperable -from autogen.interoperability.langchain import LangchainInteroperability +if sys.version_info >= (3, 9): + from autogen.interoperability.langchain import LangchainInteroperability +else: + LangchainInteroperability = unittest.mock.MagicMock() + +# skip if python version is not >= 3.9 +@pytest.mark.skipif( + sys.version_info < (3, 9), reason="Only Python 3.9 and above are supported for LangchainInteroperability" +) class TestLangchainInteroperability: @pytest.fixture(autouse=True) def setup(self) -> None: @@ -71,6 +81,10 @@ def test_with_llm(self) -> None: assert False, "No tool response found in chat messages" +# skip if python version is not >= 3.9 +@pytest.mark.skipif( + sys.version_info < (3, 9), reason="Only Python 3.9 and above are supported for LangchainInteroperability" +) class TestLangchainInteroperabilityWithoutPydanticInput: @pytest.fixture(autouse=True) def setup(self) -> None: From e6bec12766eeaf5aa44dbf36f0df40166941ee20 Mon Sep 17 00:00:00 2001 From: Mark Sze Date: Mon, 16 Dec 2024 22:33:33 +0000 Subject: [PATCH 25/70] Added LLM guidance for tool description for args, added another demo Signed-off-by: Mark Sze --- autogen/interoperability/crewai/crewai.py | 5 +- notebook/tools_crewai_tools_integration.ipynb | 233 +++++++++++++++--- 2 files changed, 204 insertions(+), 34 deletions(-) diff --git a/autogen/interoperability/crewai/crewai.py b/autogen/interoperability/crewai/crewai.py index 490dcbd81f..98df36cf05 100644 --- a/autogen/interoperability/crewai/crewai.py +++ b/autogen/interoperability/crewai/crewai.py @@ -26,7 +26,10 @@ def convert_tool(self, tool: Any) -> Tool: crewai_tool: CrewAITool = tool # type: ignore[no-any-unimported] name = _sanitize_name(crewai_tool.name) - description = crewai_tool.description.split("Tool Description: ")[-1] + description = ( + crewai_tool.description.split("Tool Description: ")[-1] + + " (IMPORTANT: When using arguments, put them all in an `args` dictionary)" + ) def func(args: crewai_tool.args_schema) -> Any: # type: ignore[no-any-unimported] return crewai_tool.run(**args.model_dump()) diff --git a/notebook/tools_crewai_tools_integration.ipynb b/notebook/tools_crewai_tools_integration.ipynb index 78b85cbccc..d0313a51f8 100644 --- a/notebook/tools_crewai_tools_integration.ipynb +++ b/notebook/tools_crewai_tools_integration.ipynb @@ -4,9 +4,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Integrating CrewAI Tools with the Autogen Framework\n", + "# Integrating CrewAI Tools with the AG2 Framework\n", "\n", - "In this tutorial, we demonstrate how to integrate [CrewAI Tools](https://github.com/crewAIInc/crewAI-tools/tree/main) into the Autogen framework. This process enables smooth interoperability between the two systems, allowing developers to leverage CrewAI's powerful tools within Autogen's flexible agent-based architecture. By the end of this guide, you will understand how to configure agents, convert CrewAI tools for use in Autogen, and validate the integration with a practical example.\n" + "In this tutorial, we demonstrate how to integrate [CrewAI Tools](https://github.com/crewAIInc/crewAI-tools/tree/main) into the AG2 framework. This process enables smooth interoperability between the two systems, allowing developers to leverage CrewAI's powerful tools within AG2's flexible agent-based architecture. By the end of this guide, you will understand how to configure agents, convert CrewAI tools for use in AG2, and validate the integration with a practical example.\n" ] }, { @@ -14,11 +14,11 @@ "metadata": {}, "source": [ "## Installation\n", - "Install the required packages for integrating CrewAI tools into the Autogen framework.\n", + "Install the required packages for integrating CrewAI tools into the AG2 framework.\n", "This ensures all dependencies for both frameworks are installed.\n", "\n", "```bash\n", - "pip install autogen[interop-crewai]\n", + "pip install ag2[interop-crewai]\n", "```" ] }, @@ -30,11 +30,11 @@ "\n", "Import necessary modules and tools.\n", "- `os` is used to access environment variables.\n", - "- `TemporaryDirectory` is used for creating a temporary workspace.\n", "- `Path` helps in handling file paths.\n", - "- `FileWriterTool` is the CrewAI tool we will integrate.\n", - "- `AssistantAgent` and `UserProxyAgent` are core Autogen classes.\n", - "- `CrewAIInteroperability` facilitates the interoperability between Autogen and CrewAI." + "- `TemporaryDirectory` is used for creating a temporary workspace.\n", + "- `FileWriterTool` and `ScrapeWebsiteTool` are the CrewAI tools we will integrate.\n", + "- `AssistantAgent` and `UserProxyAgent` are core AG2 classes.\n", + "- `CrewAIInteroperability` facilitates the interoperability between AG2 and CrewAI." ] }, { @@ -46,7 +46,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "2024-12-13 12:45:47,330 - 8269089792 - __init__.py-__init__:18 - WARNING: flaml.automl is not available. Please install flaml[automl] to enable AutoML functionalities.\n" + "/usr/local/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "2024-12-16 22:31:29,213 - 139887720012672 - __init__.py-__init__:18 - WARNING: flaml.automl is not available. Please install flaml[automl] to enable AutoML functionalities.\n" ] } ], @@ -55,7 +57,7 @@ "from pathlib import Path\n", "from tempfile import TemporaryDirectory\n", "\n", - "from crewai_tools import FileWriterTool\n", + "from crewai_tools import FileWriterTool, ScrapeWebsiteTool\n", "\n", "from autogen import AssistantAgent, UserProxyAgent\n", "from autogen.interoperability.crewai import CrewAIInteroperability" @@ -79,7 +81,7 @@ "metadata": {}, "outputs": [], "source": [ - "config_list = [{\"model\": \"gpt-4\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", + "config_list = [{\"model\": \"gpt-4o-mini\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", "user_proxy = UserProxyAgent(\n", " name=\"User\",\n", " human_input_mode=\"NEVER\",\n", @@ -97,9 +99,9 @@ "source": [ "## Tool Integration\n", "\n", - "Initialize and register the CrewAI tool with Autogen.\n", + "Initialize and register the CrewAI tool with AG2.\n", "- `crewai_tool` is an instance of the `FileWriterTool` from CrewAI.\n", - "- `CrewAIInteroperability` converts the CrewAI tool to make it usable in Autogen.\n", + "- `CrewAIInteroperability` converts the CrewAI tool to make it usable in AG2.\n", "- `register_for_execution` and `register_for_llm` allow the tool to work with the UserProxyAgent and AssistantAgent." ] }, @@ -121,7 +123,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Demonstration\n", + "## File creation\n", "\n", "Demonstrate the integration by writing to a file using the converted CrewAI tool.\n", "- A temporary directory is created to simulate a file operation environment.\n", @@ -142,22 +144,15 @@ "\u001b[33mUser\u001b[0m (to chatbot):\n", "\n", "Write 'Easy Migration :)' into tool_result.txt.\n", - "Use /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpwg6ibnmg dir.\n", + "Use /tmp/tmpt6zkd1db dir.\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mchatbot\u001b[0m (to User):\n", "\n", - "\u001b[32m***** Suggested tool call (call_en1Jhr0uYnWnMdQCaZz0WxQq): File_Writer_Tool *****\u001b[0m\n", + "\u001b[32m***** Suggested tool call (call_UR57tA4Dr5YF0aLInnRGa8eD): File_Writer_Tool *****\u001b[0m\n", "Arguments: \n", - "{\n", - " \"args\": {\n", - " \"filename\": \"tool_result.txt\",\n", - " \"directory\": \"/var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpwg6ibnmg\",\n", - " \"overwrite\": \"yes\",\n", - " \"content\": \"Easy Migration :)\"\n", - " }\n", - "}\n", + "{\"args\":{\"filename\":\"tool_result.txt\",\"directory\":\"/tmp/tmpt6zkd1db\",\"content\":\"Easy Migration :)\",\"overwrite\":\"True\"}}\n", "\u001b[32m*********************************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", @@ -166,14 +161,14 @@ "Using Tool: File Writer Tool\n", "\u001b[33mUser\u001b[0m (to chatbot):\n", "\n", - "\u001b[32m***** Response from calling tool (call_en1Jhr0uYnWnMdQCaZz0WxQq) *****\u001b[0m\n", - "Content successfully written to /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpwg6ibnmg/tool_result.txt\n", + "\u001b[32m***** Response from calling tool (call_UR57tA4Dr5YF0aLInnRGa8eD) *****\u001b[0m\n", + "Content successfully written to /tmp/tmpt6zkd1db/tool_result.txt\n", "\u001b[32m**********************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mchatbot\u001b[0m (to User):\n", "\n", - "The text \"Easy Migration :)\" has been successfully written into the file \"tool_result.txt\" in the directory \"/var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpwg6ibnmg\".\n", + "The message 'Easy Migration :)' has been successfully written to the file `tool_result.txt` in the directory `/tmp/tmpt6zkd1db`.\n", "\n", "TERMINATE\n", "\n", @@ -187,22 +182,194 @@ " message = f\"\"\"Write 'Easy Migration :)' into {filename}.\n", "Use {tmpdirname} dir.\n", "\"\"\"\n", + "\n", " user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)\n", "\n", - " assert Path(tmpdirname, filename).read_text() == \"Easy Migration :)\"\n" + " assert Path(tmpdirname, filename).read_text() == \"Easy Migration :)\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scrape the web\n", + "\n", + "Demonstrate scraping a website using the converted CrewAI tool.\n", + "- The `message` instructs the chatbot to scrape the AG2 website.\n", + "- `user_proxy.initiate_chat` starts the interaction, with the chatbot processing the request and using the tool.\n", + "- Finally, we output the summary from the LLM" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mUser\u001b[0m (to chatbot):\n", + "\n", + "Scape the website https://ag2.ai/\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mchatbot\u001b[0m (to User):\n", + "\n", + "\u001b[32m***** Suggested tool call (call_jwhEriZ8xz0sJfbNXZQYeWRH): Read_website_content *****\u001b[0m\n", + "Arguments: \n", + "{\"args\":{\"website_url\":\"https://ag2.ai/\"}}\n", + "\u001b[32m*************************************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION Read_website_content...\u001b[0m\n", + "Using Tool: Read website content\n", + "\u001b[33mUser\u001b[0m (to chatbot):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_jwhEriZ8xz0sJfbNXZQYeWRH) *****\u001b[0m\n", + "\n", + "AgentOS\n", + "Join our growing community of over 20,000 agent builders Join our growing community of over 20,000 agent builders The Open-Source AgentOS Build production-ready multi-agent systems in minutes, not months. Github Discord The End-to-End Platform for Multi-Agent Automation The End-to-End Platform for Multi-Agent Automation Flexible Agent Construction and Orchestration Create specialized agents that work together seamlessly. AG2 makes it easy to define roles, configure behaviors, and orchestrate collaboration - all through simple, intuitive code. → Assistant agents for problem-solving → Executor agents for taking action → Critic agents for validation → Group chat managers for coordination Built-in Conversation Patterns Built-in Conversation Patterns Stop wrestling with agent coordination. AG2 handles message routing, state management, and conversation flow automatically. → Two-agent conversations → Group chats with dynamic speaker selection → Sequential chats with context carryover → Nested conversations for modularity Seamless Human-AI collaboration Seamless Human-AI collaboration Seamlessly integrate human oversight and input into your agent workflows. → Configurable human input modes → Flexible intervention points → Optional human approval workflows → Interactive conversation interfaces → Context-aware human handoff Roadmap AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls Whether you're a solo founder prototyping the next big AI product, or an enterprise team deploying at scale we're building AG2 for you. This is AgentOS - making multi-agent development accessible to everyone. Github Join Our Growing Community Join Our Growing Community → 20,000+ active agent builders → Daily technical discussions → Weekly community calls → Open RFC process → Regular contributor events (Coming soon) Discord Problem Features Roadmap Community Documentation Problem Features Roadmap Community Documentation Problem Features Roadmap Community Documentation\n", + "\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mchatbot\u001b[0m (to User):\n", + "\n", + "I have scraped the content from the website https://ag2.ai/. Here are the key points:\n", + "\n", + "---\n", + "\n", + "**AgentOS**\n", + "- Join a community of over 20,000 agent builders.\n", + "- Build production-ready multi-agent systems quickly.\n", + " \n", + "**Features:**\n", + "- **Flexible Agent Construction and Orchestration**: Define roles, configure behaviors, and orchestrate collaboration through intuitive code.\n", + " - Assistant agents for problem-solving.\n", + " - Executor agents for taking action.\n", + " - Critic agents for validation.\n", + " - Group chat managers for coordination.\n", + "\n", + "- **Built-in Conversation Patterns**: Automatically handles message routing, state management, and conversation flow.\n", + " - Two-agent conversations.\n", + " - Group chats with dynamic speaker selection.\n", + " - Sequential chats with context carryover.\n", + " - Nested conversations for modularity.\n", + "\n", + "- **Seamless Human-AI Collaboration**: Integrate human oversight and input into workflows.\n", + " - Configurable human input modes.\n", + " - Flexible intervention points.\n", + " - Optional human approval workflows.\n", + " - Interactive conversation interfaces.\n", + " - Context-aware human handoff.\n", + "\n", + "**Roadmap:**\n", + "- **AG2 STUDIO**: \n", + " - Visual agent system design.\n", + " - Real-time testing and debugging.\n", + " - One-click deployment to production.\n", + "\n", + "- **AG2 MARKETPLACE**: \n", + " - Share and monetize agents.\n", + " - Discover pre-built solution templates.\n", + "\n", + "- **Scaling Tools**: \n", + " - Zero to production deployment guides.\n", + " - Usage analytics and cost optimization.\n", + " - Team collaboration features.\n", + "\n", + "---\n", + "\n", + "Whether you're a solo founder or an enterprise team, AG2 aims to make multi-agent development accessible for everyone. \n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "crewai_scrape_tool = ScrapeWebsiteTool()\n", + "ag2_tool = crewai_interop.convert_tool(crewai_scrape_tool)\n", + "\n", + "ag2_tool.register_for_execution(user_proxy)\n", + "ag2_tool.register_for_llm(chatbot)\n", + "\n", + "message = \"Scape the website https://ag2.ai/\"\n", + "\n", + "chat_result = user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I have scraped the content from the website https://ag2.ai/. Here are the key points:\n", + "\n", + "---\n", + "\n", + "**AgentOS**\n", + "- Join a community of over 20,000 agent builders.\n", + "- Build production-ready multi-agent systems quickly.\n", + " \n", + "**Features:**\n", + "- **Flexible Agent Construction and Orchestration**: Define roles, configure behaviors, and orchestrate collaboration through intuitive code.\n", + " - Assistant agents for problem-solving.\n", + " - Executor agents for taking action.\n", + " - Critic agents for validation.\n", + " - Group chat managers for coordination.\n", + "\n", + "- **Built-in Conversation Patterns**: Automatically handles message routing, state management, and conversation flow.\n", + " - Two-agent conversations.\n", + " - Group chats with dynamic speaker selection.\n", + " - Sequential chats with context carryover.\n", + " - Nested conversations for modularity.\n", + "\n", + "- **Seamless Human-AI Collaboration**: Integrate human oversight and input into workflows.\n", + " - Configurable human input modes.\n", + " - Flexible intervention points.\n", + " - Optional human approval workflows.\n", + " - Interactive conversation interfaces.\n", + " - Context-aware human handoff.\n", + "\n", + "**Roadmap:**\n", + "- **AG2 STUDIO**: \n", + " - Visual agent system design.\n", + " - Real-time testing and debugging.\n", + " - One-click deployment to production.\n", + "\n", + "- **AG2 MARKETPLACE**: \n", + " - Share and monetize agents.\n", + " - Discover pre-built solution templates.\n", + "\n", + "- **Scaling Tools**: \n", + " - Zero to production deployment guides.\n", + " - Usage analytics and cost optimization.\n", + " - Team collaboration features.\n", + "\n", + "---\n", + "\n", + "Whether you're a solo founder or an enterprise team, AG2 aims to make multi-agent development accessible for everyone. \n", + "\n", + "\n" + ] + } + ], + "source": [ + "print(chat_result.summary)" + ] } ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -216,7 +383,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.16" + "version": "3.11.10" } }, "nbformat": 4, From d8c5bac9e1d998c748e8c1defd8dcdaec95777df Mon Sep 17 00:00:00 2001 From: Mark Sze Date: Tue, 17 Dec 2024 00:28:39 +0000 Subject: [PATCH 26/70] Update crewai test for function description Signed-off-by: Mark Sze --- test/interoperability/crewai/test_crewai.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/test/interoperability/crewai/test_crewai.py b/test/interoperability/crewai/test_crewai.py index f563116a83..e2147e2af3 100644 --- a/test/interoperability/crewai/test_crewai.py +++ b/test/interoperability/crewai/test_crewai.py @@ -53,7 +53,10 @@ def test_convert_tool(self) -> None: file.write("Hello, World!") assert self.tool.name == "Read_a_file_s_content" - assert self.tool.description == "A tool that can be used to read a file's content." + assert ( + self.tool.description + == "A tool that can be used to read a file's content. (IMPORTANT: When using arguments, put them all in an `args` dictionary)" + ) args = self.model_type(file_path=file_path) From 3d759ee50c6ce6d73e3560efd3f8815734a4d432 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Tue, 17 Dec 2024 09:22:55 +0100 Subject: [PATCH 27/70] Update langchain tools integration notebook --- .../tools_langchain_tools_integration.ipynb | 110 ++++++++++++++---- 1 file changed, 89 insertions(+), 21 deletions(-) diff --git a/notebook/tools_langchain_tools_integration.ipynb b/notebook/tools_langchain_tools_integration.ipynb index 4aa42d15fe..9291f25e0d 100644 --- a/notebook/tools_langchain_tools_integration.ipynb +++ b/notebook/tools_langchain_tools_integration.ipynb @@ -1,17 +1,48 @@ { "cells": [ { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Integrating LangChain Tools with the AG2 Framework\n", + "\n", + "In this tutorial, we demonstrate how to integrate [LangChain Tools](https://python.langchain.com/v0.1/docs/modules/tools) into the AG2 framework. This process enables smooth interoperability between the two systems, allowing developers to leverage LangChain's powerful tools within AG2's flexible agent-based architecture. By the end of this guide, you will understand how to configure agents, convert LangChain tools for use in AG2, and validate the integration with a practical example.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Installation\n", + "To integrate LangChain tools into the AG2 framework, install the required dependencies:\n", + "\n", + "```bash\n", + "pip install ag2[interop-langchain]\n", + "```\n", + "\n", + "Additionally, this notebook uses LangChain's [Wikipedia Tool](https://api.python.langchain.com/en/latest/tools/langchain_community.tools.wikipedia.tool.WikipediaQueryRun.html), which requires the `wikipedia` package. Install it with:\n", + "\n", + "```bash\n", + "pip install wikipedia\n", + "```" + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# ! pip install wikipedia" + "## Imports\n", + "\n", + "Import necessary modules and tools.\n", + "- `os`: For accessing environment variables.\n", + "- `WikipediaQueryRun` and `WikipediaAPIWrapper`: Tools for querying Wikipedia.\n", + "- `AssistantAgent` and `UserProxyAgent`: Agents that facilitate communication in the Autogen framework.\n", + "- `LangchainInteroperability`: A bridge for integrating LangChain tools with the Autogen framework." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -24,9 +55,21 @@ "from autogen.interoperability.langchain import LangchainInteroperability" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Agent Configuration\n", + "\n", + "Configure the agents for the interaction.\n", + "- `config_list` defines the LLM configurations, including the model and API key.\n", + "- `UserProxyAgent` simulates user inputs without requiring actual human interaction (set to `NEVER`).\n", + "- `AssistantAgent` represents the AI agent, configured with the LLM settings." + ] + }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -42,9 +85,23 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tool Integration\n", + "\n", + "- Initialize and register the LangChain tool with AG2.\n", + "- `WikipediaAPIWrapper`: Configured to fetch the top 1 result from Wikipedia with a maximum of 1000 characters per document.\n", + "- `WikipediaQueryRun`: A LangChain tool that executes Wikipedia queries.\n", + "- `LangchainInteroperability`: Converts the LangChain tool into a format compatible with the AG2 framework.\n", + "- `ag2_tool.register_for_execution(user_proxy)`: Registers the tool for use by the user_proxy agent.\n", + "- `ag2_tool.register_for_llm(chatbot)`: Registers the tool for integration with the chatbot agent.\n" + ] + }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -52,22 +109,26 @@ "langchain_tool = WikipediaQueryRun(api_wrapper=api_wrapper)\n", "\n", "langchain_interop = LangchainInteroperability()\n", - "ag2_tool = langchain_interop.convert_tool(langchain_tool)\n" + "ag2_tool = langchain_interop.convert_tool(langchain_tool)\n", + "\n", + "ag2_tool.register_for_execution(user_proxy)\n", + "ag2_tool.register_for_llm(chatbot)\n" ] }, { - "cell_type": "code", - "execution_count": 5, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "ag2_tool.register_for_execution(user_proxy)\n", - "ag2_tool.register_for_llm(chatbot)" + "## Wikipedia Browsing\n", + "\n", + "- `user_proxy` queries the `chatbot`, which uses a Wikipedia tool to retrieve information.\n", + "- The `chatbot` identifies the query's intent and fetches a summary from Wikipedia.\n", + "- Tool execution returns a concise response from the relevant Wikipedia page." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -94,19 +155,19 @@ "\u001b[32m***** Response from calling tool (call_gBcszkAyMnQ5z1InEf4aEUmn) *****\u001b[0m\n", "Page: History of the United States\n", "Summary: The history of the lands that became the United States began with the arrival of the first people in the Americas around 15,000 BC. After European colonization of North America began in the late 15th century, wars and epidemics decimated Indigenous societies. By the 1760s, the thirteen British colonies were established. The Southern Colonies built an agricultural system on slave labor, enslaving millions from Africa. After defeating France, the British Parliament imposed a series of taxes; resistance to these taxes, especially the Boston Tea Party in 1773, led to Parliament issuing the Intolerable Acts designed to end self-government.\n", - "In 1776, the United States declared its independence. Led by General George Washington, it won the Revolutionary War in 1783. The Constitution was adopted in 1789, and a Bill of Rights was added in 1791 to guarantee inalienable rights. George Washington, the first president, and his adviser Alexander Hamilton cr\n", + "In 1776, the United States declared its independence. Led by General George Washington, it won the Revolutionary War in 1783. The Constitution was adopted in 1789, and a Bill of Rights was added in 1791 to guarantee inalienable rights. Washington, the first president, and his adviser Alexander Hamilton created a\n", "\u001b[32m**********************************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mchatbot\u001b[0m (to User):\n", "\n", - "The history of the United States began with the arrival of Native Americans in North America around 15,000 BC. European colonization of North America started in the late 15th century, which severely affected Indigenous societies through wars and epidemics.\n", + "The history of the United States started with the arrival of the first people in the Americas around 15,000 BC. The European colonization of North America began in the late 15th century, which significantly impacted Indigenous societies through wars and epidemics. By the 1760s, thirteen British colonies had been established. The Southern Colonies developed an agricultural system reliant on slave labor, bringing millions of enslaved Africans to America.\n", "\n", - "By the 1760s, thirteen British colonies had been established. The Southern Colonies developed an economy heavily reliant on slave labor, enslaving millions of people brought from Africa. The British victory over France led to increased British taxation of the colonies, leading to resistance from the colonists, exemplified by events like the Boston Tea Party in 1773.\n", + "Tensions rose between the colonies and British Parliament due to a series of taxes, with the Boston Tea Party in 1773 marking a major protest against these impositions. This led to the Intolerable Acts aimed at suppressing colonial self-governance.\n", "\n", - "The growing tensions resulted in the American colonies declaring independence in 1776. With General George Washington leading the Continental Army, the United States won the Revolutionary War against Britain in 1783. The U.S. Constitution was adopted in 1789, establishing the foundation of the federal government, and the Bill of Rights was added in 1791 to ensure individual liberties. George Washington became the nation’s first president, with Alexander Hamilton among his key advisers.\n", + "In 1776, the United States declared independence. Under the leadership of General George Washington, the U.S. emerged victorious in the Revolutionary War by 1783. The U.S. Constitution was adopted in 1789, followed by the Bill of Rights in 1791, which secured fundamental rights for its citizens. Washington became the first president, with Alexander Hamilton as a significant adviser, laying the country's early governmental foundations. \n", "\n", - "This marks the early formation and foundation of the United States as an independent nation. If you need more detailed information, let me know! TERMINATE\n", + "TERMINATE\n", "\n", "--------------------------------------------------------------------------------\n" ] @@ -114,10 +175,10 @@ { "data": { "text/plain": [ - "ChatResult(chat_id=None, chat_history=[{'content': 'Tell me about the history of the United States', 'role': 'assistant', 'name': 'User'}, {'tool_calls': [{'id': 'call_gBcszkAyMnQ5z1InEf4aEUmn', 'function': {'arguments': '{\"tool_input\":{\"query\":\"History of the United States\"}}', 'name': 'wikipedia'}, 'type': 'function'}], 'content': None, 'role': 'assistant'}, {'content': 'Page: History of the United States\\nSummary: The history of the lands that became the United States began with the arrival of the first people in the Americas around 15,000 BC. After European colonization of North America began in the late 15th century, wars and epidemics decimated Indigenous societies. By the 1760s, the thirteen British colonies were established. The Southern Colonies built an agricultural system on slave labor, enslaving millions from Africa. After defeating France, the British Parliament imposed a series of taxes; resistance to these taxes, especially the Boston Tea Party in 1773, led to Parliament issuing the Intolerable Acts designed to end self-government.\\nIn 1776, the United States declared its independence. Led by General George Washington, it won the Revolutionary War in 1783. The Constitution was adopted in 1789, and a Bill of Rights was added in 1791 to guarantee inalienable rights. George Washington, the first president, and his adviser Alexander Hamilton cr', 'tool_responses': [{'tool_call_id': 'call_gBcszkAyMnQ5z1InEf4aEUmn', 'role': 'tool', 'content': 'Page: History of the United States\\nSummary: The history of the lands that became the United States began with the arrival of the first people in the Americas around 15,000 BC. After European colonization of North America began in the late 15th century, wars and epidemics decimated Indigenous societies. By the 1760s, the thirteen British colonies were established. The Southern Colonies built an agricultural system on slave labor, enslaving millions from Africa. After defeating France, the British Parliament imposed a series of taxes; resistance to these taxes, especially the Boston Tea Party in 1773, led to Parliament issuing the Intolerable Acts designed to end self-government.\\nIn 1776, the United States declared its independence. Led by General George Washington, it won the Revolutionary War in 1783. The Constitution was adopted in 1789, and a Bill of Rights was added in 1791 to guarantee inalienable rights. George Washington, the first president, and his adviser Alexander Hamilton cr'}], 'role': 'tool', 'name': 'User'}, {'content': 'The history of the United States began with the arrival of Native Americans in North America around 15,000 BC. European colonization of North America started in the late 15th century, which severely affected Indigenous societies through wars and epidemics.\\n\\nBy the 1760s, thirteen British colonies had been established. The Southern Colonies developed an economy heavily reliant on slave labor, enslaving millions of people brought from Africa. The British victory over France led to increased British taxation of the colonies, leading to resistance from the colonists, exemplified by events like the Boston Tea Party in 1773.\\n\\nThe growing tensions resulted in the American colonies declaring independence in 1776. With General George Washington leading the Continental Army, the United States won the Revolutionary War against Britain in 1783. The U.S. Constitution was adopted in 1789, establishing the foundation of the federal government, and the Bill of Rights was added in 1791 to ensure individual liberties. George Washington became the nation’s first president, with Alexander Hamilton among his key advisers.\\n\\nThis marks the early formation and foundation of the United States as an independent nation. If you need more detailed information, let me know! TERMINATE', 'role': 'user', 'name': 'chatbot'}], summary='The history of the United States began with the arrival of Native Americans in North America around 15,000 BC. European colonization of North America started in the late 15th century, which severely affected Indigenous societies through wars and epidemics.\\n\\nBy the 1760s, thirteen British colonies had been established. The Southern Colonies developed an economy heavily reliant on slave labor, enslaving millions of people brought from Africa. The British victory over France led to increased British taxation of the colonies, leading to resistance from the colonists, exemplified by events like the Boston Tea Party in 1773.\\n\\nThe growing tensions resulted in the American colonies declaring independence in 1776. With General George Washington leading the Continental Army, the United States won the Revolutionary War against Britain in 1783. The U.S. Constitution was adopted in 1789, establishing the foundation of the federal government, and the Bill of Rights was added in 1791 to ensure individual liberties. George Washington became the nation’s first president, with Alexander Hamilton among his key advisers.\\n\\nThis marks the early formation and foundation of the United States as an independent nation. If you need more detailed information, let me know! ', cost={'usage_including_cached_inference': {'total_cost': 0.00601, 'gpt-4o-2024-08-06': {'cost': 0.00601, 'prompt_tokens': 1356, 'completion_tokens': 262, 'total_tokens': 1618}}, 'usage_excluding_cached_inference': {'total_cost': 0}}, human_input=[])" + "ChatResult(chat_id=None, chat_history=[{'content': 'Tell me about the history of the United States', 'role': 'assistant', 'name': 'User'}, {'tool_calls': [{'id': 'call_gBcszkAyMnQ5z1InEf4aEUmn', 'function': {'arguments': '{\"tool_input\":{\"query\":\"History of the United States\"}}', 'name': 'wikipedia'}, 'type': 'function'}], 'content': None, 'role': 'assistant'}, {'content': 'Page: History of the United States\\nSummary: The history of the lands that became the United States began with the arrival of the first people in the Americas around 15,000 BC. After European colonization of North America began in the late 15th century, wars and epidemics decimated Indigenous societies. By the 1760s, the thirteen British colonies were established. The Southern Colonies built an agricultural system on slave labor, enslaving millions from Africa. After defeating France, the British Parliament imposed a series of taxes; resistance to these taxes, especially the Boston Tea Party in 1773, led to Parliament issuing the Intolerable Acts designed to end self-government.\\nIn 1776, the United States declared its independence. Led by General George Washington, it won the Revolutionary War in 1783. The Constitution was adopted in 1789, and a Bill of Rights was added in 1791 to guarantee inalienable rights. Washington, the first president, and his adviser Alexander Hamilton created a', 'tool_responses': [{'tool_call_id': 'call_gBcszkAyMnQ5z1InEf4aEUmn', 'role': 'tool', 'content': 'Page: History of the United States\\nSummary: The history of the lands that became the United States began with the arrival of the first people in the Americas around 15,000 BC. After European colonization of North America began in the late 15th century, wars and epidemics decimated Indigenous societies. By the 1760s, the thirteen British colonies were established. The Southern Colonies built an agricultural system on slave labor, enslaving millions from Africa. After defeating France, the British Parliament imposed a series of taxes; resistance to these taxes, especially the Boston Tea Party in 1773, led to Parliament issuing the Intolerable Acts designed to end self-government.\\nIn 1776, the United States declared its independence. Led by General George Washington, it won the Revolutionary War in 1783. The Constitution was adopted in 1789, and a Bill of Rights was added in 1791 to guarantee inalienable rights. Washington, the first president, and his adviser Alexander Hamilton created a'}], 'role': 'tool', 'name': 'User'}, {'content': \"The history of the United States started with the arrival of the first people in the Americas around 15,000 BC. The European colonization of North America began in the late 15th century, which significantly impacted Indigenous societies through wars and epidemics. By the 1760s, thirteen British colonies had been established. The Southern Colonies developed an agricultural system reliant on slave labor, bringing millions of enslaved Africans to America.\\n\\nTensions rose between the colonies and British Parliament due to a series of taxes, with the Boston Tea Party in 1773 marking a major protest against these impositions. This led to the Intolerable Acts aimed at suppressing colonial self-governance.\\n\\nIn 1776, the United States declared independence. Under the leadership of General George Washington, the U.S. emerged victorious in the Revolutionary War by 1783. The U.S. Constitution was adopted in 1789, followed by the Bill of Rights in 1791, which secured fundamental rights for its citizens. Washington became the first president, with Alexander Hamilton as a significant adviser, laying the country's early governmental foundations. \\n\\nTERMINATE\", 'role': 'user', 'name': 'chatbot'}], summary=\"The history of the United States started with the arrival of the first people in the Americas around 15,000 BC. The European colonization of North America began in the late 15th century, which significantly impacted Indigenous societies through wars and epidemics. By the 1760s, thirteen British colonies had been established. The Southern Colonies developed an agricultural system reliant on slave labor, bringing millions of enslaved Africans to America.\\n\\nTensions rose between the colonies and British Parliament due to a series of taxes, with the Boston Tea Party in 1773 marking a major protest against these impositions. This led to the Intolerable Acts aimed at suppressing colonial self-governance.\\n\\nIn 1776, the United States declared independence. Under the leadership of General George Washington, the U.S. emerged victorious in the Revolutionary War by 1783. The U.S. Constitution was adopted in 1789, followed by the Bill of Rights in 1791, which secured fundamental rights for its citizens. Washington became the first president, with Alexander Hamilton as a significant adviser, laying the country's early governmental foundations. \\n\\n\", cost={'usage_including_cached_inference': {'total_cost': 0.00589, 'gpt-4o-2024-08-06': {'cost': 0.00589, 'prompt_tokens': 1356, 'completion_tokens': 250, 'total_tokens': 1606}}, 'usage_excluding_cached_inference': {'total_cost': 0}}, human_input=[])" ] }, - "execution_count": 6, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -126,6 +187,13 @@ "message = \"Tell me about the history of the United States\"\n", "user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 7d194fbfe700c66fc7b7b82d33ef74930180d111 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Tue, 17 Dec 2024 09:32:15 +0100 Subject: [PATCH 28/70] Update langchain tools integration notebook --- notebook/tools_langchain_tools_integration.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/notebook/tools_langchain_tools_integration.ipynb b/notebook/tools_langchain_tools_integration.ipynb index 9291f25e0d..dd1d3c3f97 100644 --- a/notebook/tools_langchain_tools_integration.ipynb +++ b/notebook/tools_langchain_tools_integration.ipynb @@ -36,8 +36,8 @@ "Import necessary modules and tools.\n", "- `os`: For accessing environment variables.\n", "- `WikipediaQueryRun` and `WikipediaAPIWrapper`: Tools for querying Wikipedia.\n", - "- `AssistantAgent` and `UserProxyAgent`: Agents that facilitate communication in the Autogen framework.\n", - "- `LangchainInteroperability`: A bridge for integrating LangChain tools with the Autogen framework." + "- `AssistantAgent` and `UserProxyAgent`: Agents that facilitate communication in the AG2 framework.\n", + "- `LangchainInteroperability`: A bridge for integrating LangChain tools with the AG2 framework." ] }, { From a69a29ba9f6aca3df27fc22df89134c6598c4a5f Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Tue, 17 Dec 2024 09:34:48 +0100 Subject: [PATCH 29/70] Fix typo --- autogen/interoperability/langchain/langchain.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/autogen/interoperability/langchain/langchain.py b/autogen/interoperability/langchain/langchain.py index d8e3590612..ad5c2a12a2 100644 --- a/autogen/interoperability/langchain/langchain.py +++ b/autogen/interoperability/langchain/langchain.py @@ -15,7 +15,7 @@ class LangchainInteroperability(Interoperable): def convert_tool(self, tool: Any) -> Tool: if not isinstance(tool, LangchainTool): - raise ValueError(f"Expected an instance of `crewai.tools.BaseTool`, got {type(tool)}") + raise ValueError(f"Expected an instance of `langchain_core.tools.BaseTool`, got {type(tool)}") # needed for type checking langchain_tool: LangchainTool = tool # type: ignore[no-any-unimported] From d2f0c53620eed4f87d715d4e46cb674221e9cf1f Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Tue, 17 Dec 2024 10:53:08 +0100 Subject: [PATCH 30/70] Clean notebooks output --- notebook/tools_crewai_tools_integration.ipynb | 257 +----------------- .../tools_langchain_tools_integration.ipynb | 56 +--- 2 files changed, 10 insertions(+), 303 deletions(-) diff --git a/notebook/tools_crewai_tools_integration.ipynb b/notebook/tools_crewai_tools_integration.ipynb index 5f82c17252..f32d2c2591 100644 --- a/notebook/tools_crewai_tools_integration.ipynb +++ b/notebook/tools_crewai_tools_integration.ipynb @@ -39,17 +39,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-12-17 08:53:37,411 - 8269089792 - __init__.py-__init__:18 - WARNING: flaml.automl is not available. Please install flaml[automl] to enable AutoML functionalities.\n" - ] - } - ], + "outputs": [], "source": [ "import os\n", "from pathlib import Path\n", @@ -132,48 +124,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[33mUser\u001b[0m (to chatbot):\n", - "\n", - "Write 'Easy Migration :)' into tool_result.txt.\n", - "Use /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpk3iyxn2v dir.\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mchatbot\u001b[0m (to User):\n", - "\n", - "\u001b[32m***** Suggested tool call (call_0CEfx7hABAt4nLq2TCd012He): File_Writer_Tool *****\u001b[0m\n", - "Arguments: \n", - "{\"args\":{\"filename\":\"tool_result.txt\",\"directory\":\"/var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpk3iyxn2v\",\"content\":\"Easy Migration :)\",\"overwrite\":\"True\"}}\n", - "\u001b[32m*********************************************************************************\u001b[0m\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[35m\n", - ">>>>>>>> EXECUTING FUNCTION File_Writer_Tool...\u001b[0m\n", - "Using Tool: File Writer Tool\n", - "\u001b[33mUser\u001b[0m (to chatbot):\n", - "\n", - "\u001b[32m***** Response from calling tool (call_0CEfx7hABAt4nLq2TCd012He) *****\u001b[0m\n", - "Content successfully written to /var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpk3iyxn2v/tool_result.txt\n", - "\u001b[32m**********************************************************************\u001b[0m\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mchatbot\u001b[0m (to User):\n", - "\n", - "The text \"Easy Migration :)\" has been successfully written into the file `tool_result.txt` located at `/var/folders/79/kmq3y0pj0rbgrrnf4xlq8q0c0000gn/T/tmpk3iyxn2v/`. \n", - "\n", - "TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n" - ] - } - ], + "outputs": [], "source": [ "with TemporaryDirectory() as tmpdirname:\n", " filename = \"tool_result.txt\"\n", @@ -188,121 +141,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[33mUser\u001b[0m (to chatbot):\n", - "\n", - "Scape the website https://ag2.ai/\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mchatbot\u001b[0m (to User):\n", - "\n", - "\u001b[32m***** Suggested tool call (call_axPfBBGebd6FUcpGP751UZgR): Read_website_content *****\u001b[0m\n", - "Arguments: \n", - "{\"args\":{\"website_url\":\"https://ag2.ai/\"}}\n", - "\u001b[32m*************************************************************************************\u001b[0m\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[35m\n", - ">>>>>>>> EXECUTING FUNCTION Read_website_content...\u001b[0m\n", - "Using Tool: Read website content\n", - "\u001b[33mUser\u001b[0m (to chatbot):\n", - "\n", - "\u001b[32m***** Response from calling tool (call_axPfBBGebd6FUcpGP751UZgR) *****\u001b[0m\n", - "\n", - "AgentOS\n", - "Join our growing community of over 20,000 agent builders Join our growing community of over 20,000 agent builders The Open-Source AgentOS Build production-ready multi-agent systems in minutes, not months. Github Discord The End-to-End Platform for Multi-Agent Automation The End-to-End Platform for Multi-Agent Automation Flexible Agent Construction and Orchestration Create specialized agents that work together seamlessly. AG2 makes it easy to define roles, configure behaviors, and orchestrate collaboration - all through simple, intuitive code. → Assistant agents for problem-solving → Executor agents for taking action → Critic agents for validation → Group chat managers for coordination Built-in Conversation Patterns Built-in Conversation Patterns Stop wrestling with agent coordination. AG2 handles message routing, state management, and conversation flow automatically. → Two-agent conversations → Group chats with dynamic speaker selection → Sequential chats with context carryover → Nested conversations for modularity Seamless Human-AI collaboration Seamless Human-AI collaboration Seamlessly integrate human oversight and input into your agent workflows. → Configurable human input modes → Flexible intervention points → Optional human approval workflows → Interactive conversation interfaces → Context-aware human handoff Roadmap AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls Whether you're a solo founder prototyping the next big AI product, or an enterprise team deploying at scale we're building AG2 for you. This is AgentOS - making multi-agent development accessible to everyone. Github Join Our Growing Community Join Our Growing Community → 20,000+ active agent builders → Daily technical discussions → Weekly community calls → Open RFC process → Regular contributor events (Coming soon) Discord Problem Features Roadmap Community Documentation Problem Features Roadmap Community Documentation Problem Features Roadmap Community Documentation\n", - "\n", - "\u001b[32m**********************************************************************\u001b[0m\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mchatbot\u001b[0m (to User):\n", - "\n", - "I have successfully scraped the content from the website https://ag2.ai/. Here's the information gathered:\n", - "\n", - "---\n", - "\n", - "**AgentOS**\n", - "\n", - "Join our growing community of over 20,000 agent builders.\n", - "\n", - "**The Open-Source AgentOS**\n", - "Build production-ready multi-agent systems in minutes, not months.\n", - "\n", - "**The End-to-End Platform for Multi-Agent Automation**\n", - "- Flexible Agent Construction and Orchestration\n", - "- Create specialized agents that work together seamlessly.\n", - "\n", - "AG2 makes it easy to define roles, configure behaviors, and orchestrate collaboration - all through simple, intuitive code.\n", - "\n", - "- Assistant agents for problem-solving\n", - "- Executor agents for taking action\n", - "- Critic agents for validation\n", - "- Group chat managers for coordination\n", - "\n", - "**Built-in Conversation Patterns**\n", - "Stop wrestling with agent coordination. AG2 handles message routing, state management, and conversation flow automatically.\n", - "\n", - "- Two-agent conversations\n", - "- Group chats with dynamic speaker selection\n", - "- Sequential chats with context carryover\n", - "- Nested conversations for modularity\n", - "\n", - "**Seamless Human-AI Collaboration**\n", - "Seamlessly integrate human oversight and input into your agent workflows.\n", - "\n", - "- Configurable human input modes\n", - "- Flexible intervention points\n", - "- Optional human approval workflows\n", - "- Interactive conversation interfaces\n", - "- Context-aware human handoff\n", - "\n", - "**Roadmap**\n", - "\n", - "- AG2 STUDIO\n", - " - Visual agent system design\n", - " - Real-time testing and debugging\n", - " - One-click deployment to production\n", - " - Perfect for prototyping and MVPs\n", - "\n", - "- AG2 MARKETPLACE\n", - " - Share and monetize your agents\n", - " - Discover pre-built solution templates\n", - " - Quick-start your agent development\n", - " - Connect with other builders\n", - "\n", - "- SCALING TOOLS\n", - " - Zero to production deployment guides\n", - " - Usage analytics and cost optimization\n", - " - Team collaboration features\n", - " - Enterprise-ready security controls\n", - "\n", - "---\n", - "\n", - "Whether you're a solo founder prototyping the next big AI product, or an enterprise team deploying at scale, AG2 is designed for you. \n", - "\n", - "**Join Our Growing Community**\n", - "- 20,000+ active agent builders\n", - "- Daily technical discussions\n", - "- Weekly community calls\n", - "- Open RFC process\n", - "- Regular contributor events (Coming soon)\n", - "\n", - "---\n", - "\n", - "If you need additional information or any specific details, please let me know! \n", - "\n", - "TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n" - ] - } - ], + "outputs": [], "source": [ "crewai_scrape_tool = ScrapeWebsiteTool()\n", "ag2_tool = crewai_interop.convert_tool(crewai_scrape_tool)\n", @@ -317,91 +158,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "I have successfully scraped the content from the website https://ag2.ai/. Here's the information gathered:\n", - "\n", - "---\n", - "\n", - "**AgentOS**\n", - "\n", - "Join our growing community of over 20,000 agent builders.\n", - "\n", - "**The Open-Source AgentOS**\n", - "Build production-ready multi-agent systems in minutes, not months.\n", - "\n", - "**The End-to-End Platform for Multi-Agent Automation**\n", - "- Flexible Agent Construction and Orchestration\n", - "- Create specialized agents that work together seamlessly.\n", - "\n", - "AG2 makes it easy to define roles, configure behaviors, and orchestrate collaboration - all through simple, intuitive code.\n", - "\n", - "- Assistant agents for problem-solving\n", - "- Executor agents for taking action\n", - "- Critic agents for validation\n", - "- Group chat managers for coordination\n", - "\n", - "**Built-in Conversation Patterns**\n", - "Stop wrestling with agent coordination. AG2 handles message routing, state management, and conversation flow automatically.\n", - "\n", - "- Two-agent conversations\n", - "- Group chats with dynamic speaker selection\n", - "- Sequential chats with context carryover\n", - "- Nested conversations for modularity\n", - "\n", - "**Seamless Human-AI Collaboration**\n", - "Seamlessly integrate human oversight and input into your agent workflows.\n", - "\n", - "- Configurable human input modes\n", - "- Flexible intervention points\n", - "- Optional human approval workflows\n", - "- Interactive conversation interfaces\n", - "- Context-aware human handoff\n", - "\n", - "**Roadmap**\n", - "\n", - "- AG2 STUDIO\n", - " - Visual agent system design\n", - " - Real-time testing and debugging\n", - " - One-click deployment to production\n", - " - Perfect for prototyping and MVPs\n", - "\n", - "- AG2 MARKETPLACE\n", - " - Share and monetize your agents\n", - " - Discover pre-built solution templates\n", - " - Quick-start your agent development\n", - " - Connect with other builders\n", - "\n", - "- SCALING TOOLS\n", - " - Zero to production deployment guides\n", - " - Usage analytics and cost optimization\n", - " - Team collaboration features\n", - " - Enterprise-ready security controls\n", - "\n", - "---\n", - "\n", - "Whether you're a solo founder prototyping the next big AI product, or an enterprise team deploying at scale, AG2 is designed for you. \n", - "\n", - "**Join Our Growing Community**\n", - "- 20,000+ active agent builders\n", - "- Daily technical discussions\n", - "- Weekly community calls\n", - "- Open RFC process\n", - "- Regular contributor events (Coming soon)\n", - "\n", - "---\n", - "\n", - "If you need additional information or any specific details, please let me know! \n", - "\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "print(chat_result.summary)" ] diff --git a/notebook/tools_langchain_tools_integration.ipynb b/notebook/tools_langchain_tools_integration.ipynb index dd1d3c3f97..3fb4d68594 100644 --- a/notebook/tools_langchain_tools_integration.ipynb +++ b/notebook/tools_langchain_tools_integration.ipynb @@ -128,61 +128,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[33mUser\u001b[0m (to chatbot):\n", - "\n", - "Tell me about the history of the United States\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mchatbot\u001b[0m (to User):\n", - "\n", - "\u001b[32m***** Suggested tool call (call_gBcszkAyMnQ5z1InEf4aEUmn): wikipedia *****\u001b[0m\n", - "Arguments: \n", - "{\"tool_input\":{\"query\":\"History of the United States\"}}\n", - "\u001b[32m**************************************************************************\u001b[0m\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[35m\n", - ">>>>>>>> EXECUTING FUNCTION wikipedia...\u001b[0m\n", - "\u001b[33mUser\u001b[0m (to chatbot):\n", - "\n", - "\u001b[32m***** Response from calling tool (call_gBcszkAyMnQ5z1InEf4aEUmn) *****\u001b[0m\n", - "Page: History of the United States\n", - "Summary: The history of the lands that became the United States began with the arrival of the first people in the Americas around 15,000 BC. After European colonization of North America began in the late 15th century, wars and epidemics decimated Indigenous societies. By the 1760s, the thirteen British colonies were established. The Southern Colonies built an agricultural system on slave labor, enslaving millions from Africa. After defeating France, the British Parliament imposed a series of taxes; resistance to these taxes, especially the Boston Tea Party in 1773, led to Parliament issuing the Intolerable Acts designed to end self-government.\n", - "In 1776, the United States declared its independence. Led by General George Washington, it won the Revolutionary War in 1783. The Constitution was adopted in 1789, and a Bill of Rights was added in 1791 to guarantee inalienable rights. Washington, the first president, and his adviser Alexander Hamilton created a\n", - "\u001b[32m**********************************************************************\u001b[0m\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mchatbot\u001b[0m (to User):\n", - "\n", - "The history of the United States started with the arrival of the first people in the Americas around 15,000 BC. The European colonization of North America began in the late 15th century, which significantly impacted Indigenous societies through wars and epidemics. By the 1760s, thirteen British colonies had been established. The Southern Colonies developed an agricultural system reliant on slave labor, bringing millions of enslaved Africans to America.\n", - "\n", - "Tensions rose between the colonies and British Parliament due to a series of taxes, with the Boston Tea Party in 1773 marking a major protest against these impositions. This led to the Intolerable Acts aimed at suppressing colonial self-governance.\n", - "\n", - "In 1776, the United States declared independence. Under the leadership of General George Washington, the U.S. emerged victorious in the Revolutionary War by 1783. The U.S. Constitution was adopted in 1789, followed by the Bill of Rights in 1791, which secured fundamental rights for its citizens. Washington became the first president, with Alexander Hamilton as a significant adviser, laying the country's early governmental foundations. \n", - "\n", - "TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n" - ] - }, - { - "data": { - "text/plain": [ - "ChatResult(chat_id=None, chat_history=[{'content': 'Tell me about the history of the United States', 'role': 'assistant', 'name': 'User'}, {'tool_calls': [{'id': 'call_gBcszkAyMnQ5z1InEf4aEUmn', 'function': {'arguments': '{\"tool_input\":{\"query\":\"History of the United States\"}}', 'name': 'wikipedia'}, 'type': 'function'}], 'content': None, 'role': 'assistant'}, {'content': 'Page: History of the United States\\nSummary: The history of the lands that became the United States began with the arrival of the first people in the Americas around 15,000 BC. After European colonization of North America began in the late 15th century, wars and epidemics decimated Indigenous societies. By the 1760s, the thirteen British colonies were established. The Southern Colonies built an agricultural system on slave labor, enslaving millions from Africa. After defeating France, the British Parliament imposed a series of taxes; resistance to these taxes, especially the Boston Tea Party in 1773, led to Parliament issuing the Intolerable Acts designed to end self-government.\\nIn 1776, the United States declared its independence. Led by General George Washington, it won the Revolutionary War in 1783. The Constitution was adopted in 1789, and a Bill of Rights was added in 1791 to guarantee inalienable rights. Washington, the first president, and his adviser Alexander Hamilton created a', 'tool_responses': [{'tool_call_id': 'call_gBcszkAyMnQ5z1InEf4aEUmn', 'role': 'tool', 'content': 'Page: History of the United States\\nSummary: The history of the lands that became the United States began with the arrival of the first people in the Americas around 15,000 BC. After European colonization of North America began in the late 15th century, wars and epidemics decimated Indigenous societies. By the 1760s, the thirteen British colonies were established. The Southern Colonies built an agricultural system on slave labor, enslaving millions from Africa. After defeating France, the British Parliament imposed a series of taxes; resistance to these taxes, especially the Boston Tea Party in 1773, led to Parliament issuing the Intolerable Acts designed to end self-government.\\nIn 1776, the United States declared its independence. Led by General George Washington, it won the Revolutionary War in 1783. The Constitution was adopted in 1789, and a Bill of Rights was added in 1791 to guarantee inalienable rights. Washington, the first president, and his adviser Alexander Hamilton created a'}], 'role': 'tool', 'name': 'User'}, {'content': \"The history of the United States started with the arrival of the first people in the Americas around 15,000 BC. The European colonization of North America began in the late 15th century, which significantly impacted Indigenous societies through wars and epidemics. By the 1760s, thirteen British colonies had been established. The Southern Colonies developed an agricultural system reliant on slave labor, bringing millions of enslaved Africans to America.\\n\\nTensions rose between the colonies and British Parliament due to a series of taxes, with the Boston Tea Party in 1773 marking a major protest against these impositions. This led to the Intolerable Acts aimed at suppressing colonial self-governance.\\n\\nIn 1776, the United States declared independence. Under the leadership of General George Washington, the U.S. emerged victorious in the Revolutionary War by 1783. The U.S. Constitution was adopted in 1789, followed by the Bill of Rights in 1791, which secured fundamental rights for its citizens. Washington became the first president, with Alexander Hamilton as a significant adviser, laying the country's early governmental foundations. \\n\\nTERMINATE\", 'role': 'user', 'name': 'chatbot'}], summary=\"The history of the United States started with the arrival of the first people in the Americas around 15,000 BC. The European colonization of North America began in the late 15th century, which significantly impacted Indigenous societies through wars and epidemics. By the 1760s, thirteen British colonies had been established. The Southern Colonies developed an agricultural system reliant on slave labor, bringing millions of enslaved Africans to America.\\n\\nTensions rose between the colonies and British Parliament due to a series of taxes, with the Boston Tea Party in 1773 marking a major protest against these impositions. This led to the Intolerable Acts aimed at suppressing colonial self-governance.\\n\\nIn 1776, the United States declared independence. Under the leadership of General George Washington, the U.S. emerged victorious in the Revolutionary War by 1783. The U.S. Constitution was adopted in 1789, followed by the Bill of Rights in 1791, which secured fundamental rights for its citizens. Washington became the first president, with Alexander Hamilton as a significant adviser, laying the country's early governmental foundations. \\n\\n\", cost={'usage_including_cached_inference': {'total_cost': 0.00589, 'gpt-4o-2024-08-06': {'cost': 0.00589, 'prompt_tokens': 1356, 'completion_tokens': 250, 'total_tokens': 1606}}, 'usage_excluding_cached_inference': {'total_cost': 0}}, human_input=[])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "message = \"Tell me about the history of the United States\"\n", "user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)" From 1b55bd761d94a6b93f157fe5d22da85b984a59a9 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Tue, 17 Dec 2024 11:11:11 +0100 Subject: [PATCH 31/70] new interop target introduced to simplify CI Signed-off-by: Davor Runje --- .github/workflows/build.yml | 2 +- .github/workflows/openai.yml | 2 +- setup.py | 8 ++++++-- setup_ag2.py | 1 + setup_autogen.py | 1 + 5 files changed, 10 insertions(+), 4 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 9cec9d24bb..70b17929fe 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -71,7 +71,7 @@ jobs: - name: Install packages and dependencies run: | python -m pip install --upgrade pip wheel - pip install -e .[test,cosmosdb,interop-crewai,interop-langchain] + pip install -e .[test,cosmosdb,interop] python -c "import autogen" pip install pytest-cov>=5 mock - name: Install optional dependencies for code executors diff --git a/.github/workflows/openai.yml b/.github/workflows/openai.yml index a536102e20..d7dbbba492 100644 --- a/.github/workflows/openai.yml +++ b/.github/workflows/openai.yml @@ -55,7 +55,7 @@ jobs: if: matrix.python-version == '3.9' run: | pip install docker - pip install -e .[redis,interop-crewai,interop-langchain] + pip install -e .[redis,interop] - name: Coverage if: matrix.python-version == '3.9' env: diff --git a/setup.py b/setup.py index 855f7c9ffd..88e6a62e96 100644 --- a/setup.py +++ b/setup.py @@ -69,6 +69,9 @@ "llama-index-core==0.12.5", ] +interop_crewai = ["crewai[tools]>=0.86,<1; python_version>='3.10' and python_version<'3.13'"] +interop_langchain = ["langchain-community>=0.3.12,<1; python_version>='3.9'"] + if current_os in ["Windows", "Darwin"]: retrieve_chat_pgvector.extend(["psycopg[binary]>=3.1.18"]) elif current_os == "Linux": @@ -122,8 +125,9 @@ "cohere": ["cohere>=5.5.8"], "ollama": ["ollama>=0.3.3", "fix_busted_json>=0.0.18"], "bedrock": ["boto3>=1.34.149"], - "interop-crewai": ["crewai[tools]>=0.86,<1; python_version>='3.10' and python_version<'3.13'"], - "interop-langchain": ["langchain-community>=0.3.12,<1; python_version>='3.9'"], + "interop-crewai": interop_crewai, + "interop-langchain": interop_langchain, + "interop": interop_crewai + interop_langchain, "neo4j": neo4j, } diff --git a/setup_ag2.py b/setup_ag2.py index bd7077b182..f0015dda36 100644 --- a/setup_ag2.py +++ b/setup_ag2.py @@ -56,6 +56,7 @@ "bedrock": ["pyautogen[bedrock]==" + __version__], "interop-crewai": ["pyautogen[interop-crewai]==" + __version__], "interop-langchain": ["pyautogen[interop-langchain]==" + __version__], + "interop": ["pyautogen[interop]==" + __version__], "neo4j": ["pyautogen[neo4j]==" + __version__], }, url="https://github.com/ag2ai/ag2", diff --git a/setup_autogen.py b/setup_autogen.py index 16f43b4284..520b7294d5 100644 --- a/setup_autogen.py +++ b/setup_autogen.py @@ -56,6 +56,7 @@ "bedrock": ["pyautogen[bedrock]==" + __version__], "interop-crewai": ["pyautogen[interop-crewai]==" + __version__], "interop-langchain": ["pyautogen[interop-langchain]==" + __version__], + "interop": ["pyautogen[interop]==" + __version__], "neo4j": ["pyautogen[neo4j]==" + __version__], }, url="https://github.com/ag2ai/ag2", From c9722b39d1b1cd048f4ea62046b9acd6cdaea404 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Tue, 17 Dec 2024 11:21:49 +0100 Subject: [PATCH 32/70] refactoring and test fix Signed-off-by: Davor Runje --- autogen/{interoperability => interop}/__init__.py | 0 .../{interoperability => interop}/crewai/__init__.py | 0 autogen/{interoperability => interop}/crewai/crewai.py | 0 .../{interoperability => interop}/interoperability.py | 0 .../langchain/__init__.py | 0 .../langchain/langchain.py | 0 pyproject.toml | 4 ++-- test/{interoperability => interop}/__init__.py | 0 test/{interoperability => interop}/crewai/__init__.py | 0 .../crewai/test_crewai.py | 4 ++-- .../langchain/__init__.py | 0 .../langchain/test_langchain.py | 10 ++++++---- .../test_interoperability.py | 2 +- 13 files changed, 11 insertions(+), 9 deletions(-) rename autogen/{interoperability => interop}/__init__.py (100%) rename autogen/{interoperability => interop}/crewai/__init__.py (100%) rename autogen/{interoperability => interop}/crewai/crewai.py (100%) rename autogen/{interoperability => interop}/interoperability.py (100%) rename autogen/{interoperability => interop}/langchain/__init__.py (100%) rename autogen/{interoperability => interop}/langchain/langchain.py (100%) rename test/{interoperability => interop}/__init__.py (100%) rename test/{interoperability => interop}/crewai/__init__.py (100%) rename test/{interoperability => interop}/crewai/test_crewai.py (96%) rename test/{interoperability => interop}/langchain/__init__.py (100%) rename test/{interoperability => interop}/langchain/test_langchain.py (95%) rename test/{interoperability => interop}/test_interoperability.py (77%) diff --git a/autogen/interoperability/__init__.py b/autogen/interop/__init__.py similarity index 100% rename from autogen/interoperability/__init__.py rename to autogen/interop/__init__.py diff --git a/autogen/interoperability/crewai/__init__.py b/autogen/interop/crewai/__init__.py similarity index 100% rename from autogen/interoperability/crewai/__init__.py rename to autogen/interop/crewai/__init__.py diff --git a/autogen/interoperability/crewai/crewai.py b/autogen/interop/crewai/crewai.py similarity index 100% rename from autogen/interoperability/crewai/crewai.py rename to autogen/interop/crewai/crewai.py diff --git a/autogen/interoperability/interoperability.py b/autogen/interop/interoperability.py similarity index 100% rename from autogen/interoperability/interoperability.py rename to autogen/interop/interoperability.py diff --git a/autogen/interoperability/langchain/__init__.py b/autogen/interop/langchain/__init__.py similarity index 100% rename from autogen/interoperability/langchain/__init__.py rename to autogen/interop/langchain/__init__.py diff --git a/autogen/interoperability/langchain/langchain.py b/autogen/interop/langchain/langchain.py similarity index 100% rename from autogen/interoperability/langchain/langchain.py rename to autogen/interop/langchain/langchain.py diff --git a/pyproject.toml b/pyproject.toml index 66b4bb2b56..74a6d04c1e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -61,12 +61,12 @@ files = [ "autogen/function_utils.py", "autogen/io", "autogen/tools", - "autogen/interoperability", + "autogen/interop", "test/test_pydantic.py", "test/test_function_utils.py", "test/io", "test/tools", - "test/interoperability", + "test/interop", ] exclude = [ "autogen/math_utils\\.py", diff --git a/test/interoperability/__init__.py b/test/interop/__init__.py similarity index 100% rename from test/interoperability/__init__.py rename to test/interop/__init__.py diff --git a/test/interoperability/crewai/__init__.py b/test/interop/crewai/__init__.py similarity index 100% rename from test/interoperability/crewai/__init__.py rename to test/interop/crewai/__init__.py diff --git a/test/interoperability/crewai/test_crewai.py b/test/interop/crewai/test_crewai.py similarity index 96% rename from test/interoperability/crewai/test_crewai.py rename to test/interop/crewai/test_crewai.py index 7c35af4a3f..1f0bae4bb1 100644 --- a/test/interoperability/crewai/test_crewai.py +++ b/test/interop/crewai/test_crewai.py @@ -16,10 +16,10 @@ FileReadTool = unittest.mock.MagicMock() from autogen import AssistantAgent, UserProxyAgent -from autogen.interoperability import Interoperable +from autogen.interop import Interoperable if sys.version_info >= (3, 10) and sys.version_info < (3, 13): - from autogen.interoperability.crewai import CrewAIInteroperability + from autogen.interop.crewai import CrewAIInteroperability else: CrewAIInteroperability = unittest.mock.MagicMock() diff --git a/test/interoperability/langchain/__init__.py b/test/interop/langchain/__init__.py similarity index 100% rename from test/interoperability/langchain/__init__.py rename to test/interop/langchain/__init__.py diff --git a/test/interoperability/langchain/test_langchain.py b/test/interop/langchain/test_langchain.py similarity index 95% rename from test/interoperability/langchain/test_langchain.py rename to test/interop/langchain/test_langchain.py index 8ab346ff40..070c396784 100644 --- a/test/interoperability/langchain/test_langchain.py +++ b/test/interop/langchain/test_langchain.py @@ -8,15 +8,17 @@ import pytest from conftest import reason, skip_openai -from langchain.tools import tool from pydantic import BaseModel, Field from autogen import AssistantAgent, UserProxyAgent -from autogen.interoperability import Interoperable +from autogen.interop import Interoperable if sys.version_info >= (3, 9): - from autogen.interoperability.langchain import LangchainInteroperability + from langchain.tools import tool + + from autogen.interop.langchain import LangchainInteroperability else: + tool = unittest.mock.MagicMock() LangchainInteroperability = unittest.mock.MagicMock() @@ -88,7 +90,7 @@ def test_with_llm(self) -> None: class TestLangchainInteroperabilityWithoutPydanticInput: @pytest.fixture(autouse=True) def setup(self) -> None: - @tool # type: ignore[misc] + @tool def search(query: str, max_length: int) -> str: """Look up things online.""" return f"LangChain Integration, max_length: {max_length}" diff --git a/test/interoperability/test_interoperability.py b/test/interop/test_interoperability.py similarity index 77% rename from test/interoperability/test_interoperability.py rename to test/interop/test_interoperability.py index 185cf4b571..164854f6aa 100644 --- a/test/interoperability/test_interoperability.py +++ b/test/interop/test_interoperability.py @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: Apache-2.0 -from autogen.interoperability import Interoperable +from autogen.interop import Interoperable def test_interoperable() -> None: From 1ee6412fd8e46b9db548fd753c3cdd8d4564efbd Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Tue, 17 Dec 2024 16:02:53 +0100 Subject: [PATCH 33/70] Testing pydantic ai tools --- notebook/pydantic_ai.ipynb | 637 +++++++++++++++++++++++++++++++++++++ 1 file changed, 637 insertions(+) create mode 100644 notebook/pydantic_ai.ipynb diff --git a/notebook/pydantic_ai.ipynb b/notebook/pydantic_ai.ipynb new file mode 100644 index 0000000000..8d38ffe936 --- /dev/null +++ b/notebook/pydantic_ai.ipynb @@ -0,0 +1,637 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# ! pip install pydantic-ai" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tools WITHOUT Context " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "\n", + "from pydantic_ai import RunContext, Tool\n", + "\n", + "\n", + "def roll_dice(name: str = \"Rolling dice\") -> str:\n", + " \"\"\"Roll a six-sided dice and return the result.\"\"\"\n", + " return str(random.randint(1, 6))\n", + "\n", + "\n", + "rool_dice_tool = Tool(roll_dice)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'5'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rool_dice_tool.function()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "roll_dice\n", + "Roll a six-sided dice and return the result.\n" + ] + } + ], + "source": [ + "print(rool_dice_tool.name)\n", + "print(rool_dice_tool.description)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'properties': {'name': {'title': 'Name', 'type': 'string'}},\n", + " 'required': ['name'],\n", + " 'type': 'object',\n", + " 'additionalProperties': False}" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rool_dice_tool._parameters_json_schema" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "foobar\n", + "Get me foobar.\n" + ] + } + ], + "source": [ + "from typing import Optional\n", + "\n", + "\n", + "def foobar(a: int, b: str, c: Optional[dict[str, list[float]]] = None) -> str:\n", + " \"\"\"Get me foobar.\n", + "\n", + " Args:\n", + " a: apple pie\n", + " b: banana cake\n", + " c: carrot smoothie\n", + " \"\"\"\n", + " return f\"{a} {b} {c}\"\n", + "\n", + "\n", + "foobar_tool = Tool(foobar)\n", + "\n", + "print(foobar_tool.name)\n", + "print(foobar_tool.description)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'properties': {'a': {'description': 'apple pie',\n", + " 'title': 'A',\n", + " 'type': 'integer'},\n", + " 'b': {'description': 'banana cake', 'title': 'B', 'type': 'string'},\n", + " 'c': {'anyOf': [{'additionalProperties': {'items': {'type': 'number'},\n", + " 'type': 'array'},\n", + " 'type': 'object'},\n", + " {'type': 'null'}],\n", + " 'description': 'carrot smoothie',\n", + " 'title': 'C'}},\n", + " 'required': ['a', 'b', 'c'],\n", + " 'type': 'object',\n", + " 'additionalProperties': False}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "foobar_tool._parameters_json_schema" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tools WITH Context (simple string)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def get_player_name(ctx: RunContext[str]) -> str:\n", + " \"\"\"Get the player's name.\"\"\"\n", + " return ctx.deps\n", + "\n", + "\n", + "get_player_name_tool = Tool(get_player_name, takes_ctx=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# ! pip install nest_asyncio" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import nest_asyncio\n", + "\n", + "nest_asyncio.apply()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from pydantic_ai import Agent\n", + "\n", + "agent_a = Agent(\n", + " \"openai:gpt-4o\",\n", + " deps_type=str,\n", + " tools=[get_player_name_tool],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "RunResult(_all_messages=[ModelRequest(parts=[UserPromptPart(content='Get players name', timestamp=datetime.datetime(2024, 12, 17, 15, 1, 58, 163148, tzinfo=datetime.timezone.utc), part_kind='user-prompt')], kind='request'), ModelResponse(parts=[ToolCallPart(tool_name='get_player_name', args=ArgsJson(args_json='{}'), tool_call_id='call_410yrIwckDRCr9wSF0GXy8eL', part_kind='tool-call')], timestamp=datetime.datetime(2024, 12, 17, 15, 1, 58, tzinfo=datetime.timezone.utc), kind='response'), ModelRequest(parts=[ToolReturnPart(tool_name='get_player_name', content='Anne', tool_call_id='call_410yrIwckDRCr9wSF0GXy8eL', timestamp=datetime.datetime(2024, 12, 17, 15, 1, 59, 95607, tzinfo=datetime.timezone.utc), part_kind='tool-return')], kind='request'), ModelResponse(parts=[TextPart(content=\"The player's name is Anne.\", part_kind='text')], timestamp=datetime.datetime(2024, 12, 17, 15, 1, 59, tzinfo=datetime.timezone.utc), kind='response')], _new_message_index=0, data=\"The player's name is Anne.\", _cost=Cost(request_tokens=101, response_tokens=18, total_tokens=119, details={'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0, 'cached_tokens': 0}))" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result = agent_a.run_sync(\"Get players name\", deps=\"Anne\")\n", + "result" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ModelRequest(parts=[UserPromptPart(content='Get players name', timestamp=datetime.datetime(2024, 12, 17, 15, 1, 58, 163148, tzinfo=datetime.timezone.utc), part_kind='user-prompt')], kind='request'),\n", + " ModelResponse(parts=[ToolCallPart(tool_name='get_player_name', args=ArgsJson(args_json='{}'), tool_call_id='call_410yrIwckDRCr9wSF0GXy8eL', part_kind='tool-call')], timestamp=datetime.datetime(2024, 12, 17, 15, 1, 58, tzinfo=datetime.timezone.utc), kind='response'),\n", + " ModelRequest(parts=[ToolReturnPart(tool_name='get_player_name', content='Anne', tool_call_id='call_410yrIwckDRCr9wSF0GXy8eL', timestamp=datetime.datetime(2024, 12, 17, 15, 1, 59, 95607, tzinfo=datetime.timezone.utc), part_kind='tool-return')], kind='request'),\n", + " ModelResponse(parts=[TextPart(content=\"The player's name is Anne.\", part_kind='text')], timestamp=datetime.datetime(2024, 12, 17, 15, 1, 59, tzinfo=datetime.timezone.utc), kind='response')]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.all_messages()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tools WITH Context (pydantic)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from pydantic import BaseModel\n", + "\n", + "\n", + "class Player(BaseModel):\n", + " name: str\n", + " age: int\n", + "\n", + "\n", + "def get_player(ctx: RunContext[Player], additional_info: Optional[str] = None) -> str:\n", + " \"\"\"Get the player's name.\n", + "\n", + " Args:\n", + " additional_info: Additional information which can be used.\n", + " \"\"\"\n", + " return f\"Name: {ctx.deps.name}, Age: {ctx.deps.age}, Additional info: {additional_info}\"\n", + "\n", + "\n", + "get_player_tool = Tool(get_player, takes_ctx=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "get_player\n", + "Get the player's name.\n", + "{'properties': {'additional_info': {'anyOf': [{'type': 'string'}, {'type': 'null'}], 'description': 'Additional information which can be used.', 'title': 'Additional Info'}}, 'required': ['additional_info'], 'type': 'object', 'additionalProperties': False}\n" + ] + } + ], + "source": [ + "print(get_player_tool.name)\n", + "print(get_player_tool.description)\n", + "print(get_player_tool._parameters_json_schema)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[ModelRequest(parts=[UserPromptPart(content='Get player', timestamp=datetime.datetime(2024, 12, 17, 15, 1, 59, 708795, tzinfo=datetime.timezone.utc), part_kind='user-prompt')], kind='request'),\n", + " ModelResponse(parts=[TextPart(content=\"Could you please provide any additional information or context regarding the player you're interested in? This will help me deliver the most relevant details for you.\", part_kind='text')], timestamp=datetime.datetime(2024, 12, 17, 15, 2, tzinfo=datetime.timezone.utc), kind='response')]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agent_b = Agent(\n", + " \"openai:gpt-4o\",\n", + " deps_type=Player,\n", + " tools=[get_player_tool],\n", + ")\n", + "\n", + "player = Player(name=\"Luka\", age=25)\n", + "result_b = agent_b.run_sync(\"Get player\", deps=player)\n", + "result_b.all_messages()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dependency injection" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# Initial Source: https://github.com/airtai/fastagency/blob/main/fastagency/api/dependency_injection.py\n", + "\n", + "from functools import wraps\n", + "from inspect import signature\n", + "from typing import Any, Callable\n", + "\n", + "\n", + "def inject_params(f: Callable[..., Any], ctx: Any) -> Callable[..., Any]:\n", + "\n", + " @wraps(f)\n", + " def wrapper(*args: Any, **kwargs: Any) -> Any:\n", + " kwargs.pop(\"ctx\", None)\n", + " return f(**kwargs, ctx=ctx)\n", + "\n", + " sig = signature(f)\n", + " new_params = [param for name, param in sig.parameters.items() if name != \"ctx\"]\n", + "\n", + " wrapper.__signature__ = sig.replace(parameters=new_params) # type: ignore[attr-defined]\n", + "\n", + " return wrapper" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "ctx = RunContext(\n", + " deps=Player(name=\"Luka\", age=25),\n", + " retry=get_player_tool.max_retries, # Not sure\n", + " messages=[], # Not sure\n", + " tool_name=get_player_tool.name,\n", + ")\n", + "f_injected = inject_params(f=get_player_tool.function, ctx=ctx)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " str>" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f_injected.__signature__" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Name: Luka, Age: 25, Additional info: Hello'" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f_injected(additional_info=\"Hello\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## AG2 Integration" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "from autogen import AssistantAgent, UserProxyAgent" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "config_list = [{\"model\": \"gpt-4o\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", + "user_proxy = UserProxyAgent(\n", + " name=\"User\",\n", + " human_input_mode=\"NEVER\",\n", + ")\n", + "\n", + "chatbot = AssistantAgent(\n", + " name=\"chatbot\",\n", + " llm_config={\"config_list\": config_list},\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "tool = get_player_tool\n", + "\n", + "f_injected_ctx = inject_params(f=tool.function, ctx=ctx)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " str>" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "user_proxy.register_for_execution(name=tool.name)(f_injected_ctx)\n", + "chatbot.register_for_llm(description=tool.description, name=tool.name)(f_injected_ctx)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'type': 'function',\n", + " 'function': {'description': \"Get the player's name.\",\n", + " 'name': 'get_player',\n", + " 'parameters': {'type': 'object',\n", + " 'properties': {'additional_info': {'anyOf': [{'type': 'string'},\n", + " {'type': 'null'}],\n", + " 'default': None,\n", + " 'description': 'additional_info'}},\n", + " 'required': []}}}]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "chatbot.llm_config[\"tools\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mUser\u001b[0m (to chatbot):\n", + "\n", + "Get player, for additional information use 'goal keeper'\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mchatbot\u001b[0m (to User):\n", + "\n", + "\u001b[32m***** Suggested tool call (call_S1wA3FAaTLFAt5aLv19xwOXJ): get_player *****\u001b[0m\n", + "Arguments: \n", + "{\"additional_info\":\"goal keeper\"}\n", + "\u001b[32m***************************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION get_player...\u001b[0m\n", + "\u001b[33mUser\u001b[0m (to chatbot):\n", + "\n", + "\u001b[32m***** Response from calling tool (call_S1wA3FAaTLFAt5aLv19xwOXJ) *****\u001b[0m\n", + "Name: Luka, Age: 25, Additional info: goal keeper\n", + "\u001b[32m**********************************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mchatbot\u001b[0m (to User):\n", + "\n", + "The player's name is Luka, aged 25, and is a goal keeper. TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mUser\u001b[0m (to chatbot):\n", + "\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mchatbot\u001b[0m (to User):\n", + "\n", + "It seems like there was no follow-up request. If there's anything else you need, feel free to ask! TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "data": { + "text/plain": [ + "ChatResult(chat_id=None, chat_history=[{'content': \"Get player, for additional information use 'goal keeper'\", 'role': 'assistant', 'name': 'User'}, {'tool_calls': [{'id': 'call_S1wA3FAaTLFAt5aLv19xwOXJ', 'function': {'arguments': '{\"additional_info\":\"goal keeper\"}', 'name': 'get_player'}, 'type': 'function'}], 'content': None, 'role': 'assistant'}, {'content': 'Name: Luka, Age: 25, Additional info: goal keeper', 'tool_responses': [{'tool_call_id': 'call_S1wA3FAaTLFAt5aLv19xwOXJ', 'role': 'tool', 'content': 'Name: Luka, Age: 25, Additional info: goal keeper'}], 'role': 'tool', 'name': 'User'}, {'content': \"The player's name is Luka, aged 25, and is a goal keeper. TERMINATE\", 'role': 'user', 'name': 'chatbot'}, {'content': '', 'role': 'assistant', 'name': 'User'}, {'content': \"It seems like there was no follow-up request. If there's anything else you need, feel free to ask! TERMINATE\", 'role': 'user', 'name': 'chatbot'}], summary=\"It seems like there was no follow-up request. If there's anything else you need, feel free to ask! \", cost={'usage_including_cached_inference': {'total_cost': 0.0047675, 'gpt-4o-2024-08-06': {'cost': 0.0047675, 'prompt_tokens': 1667, 'completion_tokens': 60, 'total_tokens': 1727}}, 'usage_excluding_cached_inference': {'total_cost': 0}}, human_input=[])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "user_proxy.initiate_chat(\n", + " recipient=chatbot, message=\"Get player, for additional information use 'goal keeper'\", max_turns=3\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 74332eb12236a642de9f803bdc2738d00d087b53 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Wed, 18 Dec 2024 08:49:58 +0100 Subject: [PATCH 34/70] Initial pydantic ai tools implementation --- autogen/interop/pydantic_ai/__init__.py | 19 +++ autogen/interop/pydantic_ai/pydantic_ai.py | 56 ++++++ setup.py | 4 +- setup_ag2.py | 1 + setup_autogen.py | 1 + test/interop/pydantic_ai/__init__.py | 3 + test/interop/pydantic_ai/test_pydantic_ai.py | 170 +++++++++++++++++++ 7 files changed, 253 insertions(+), 1 deletion(-) create mode 100644 autogen/interop/pydantic_ai/__init__.py create mode 100644 autogen/interop/pydantic_ai/pydantic_ai.py create mode 100644 test/interop/pydantic_ai/__init__.py create mode 100644 test/interop/pydantic_ai/test_pydantic_ai.py diff --git a/autogen/interop/pydantic_ai/__init__.py b/autogen/interop/pydantic_ai/__init__.py new file mode 100644 index 0000000000..55d52347ce --- /dev/null +++ b/autogen/interop/pydantic_ai/__init__.py @@ -0,0 +1,19 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +import sys + +if sys.version_info < (3, 9): + raise ImportError("This submodule is only supported for Python versions 3.9 and above") + +try: + import pydantic_ai.tools +except ImportError: + raise ImportError( + "Please install `interop-pydantic-ai` extra to use this module:\n\n\tpip install ag2[interop-pydantic-ai]" + ) + +from .pydantic_ai import PydanticAIInteroperability + +__all__ = ["PydanticAIInteroperability"] diff --git a/autogen/interop/pydantic_ai/pydantic_ai.py b/autogen/interop/pydantic_ai/pydantic_ai.py new file mode 100644 index 0000000000..2e77d6ef71 --- /dev/null +++ b/autogen/interop/pydantic_ai/pydantic_ai.py @@ -0,0 +1,56 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + + +from functools import wraps +from inspect import signature +from typing import Any, Callable + +from pydantic_ai import RunContext +from pydantic_ai.tools import Tool as PydanticAITool + +from ...tools import Tool +from ..interoperability import Interoperable + +__all__ = ["PydanticAIInteroperability"] + + +class PydanticAIInteroperability(Interoperable): + @staticmethod + def inject_params(f: Callable[..., Any], ctx: Any) -> Callable[..., Any]: + @wraps(f) + def wrapper(*args: Any, **kwargs: Any) -> Any: + kwargs.pop("ctx", None) + return f(**kwargs, ctx=ctx) + + sig = signature(f) + new_params = [param for name, param in sig.parameters.items() if name != "ctx"] + + wrapper.__signature__ = sig.replace(parameters=new_params) # type: ignore[attr-defined] + + return wrapper + + def convert_tool(self, tool: Any, deps: Any = None) -> Tool: + if not isinstance(tool, PydanticAITool): + raise ValueError(f"Expected an instance of `pydantic_ai.tools.Tool`, got {type(tool)}") + + # needed for type checking + pydantic_ai_tool: PydanticAITool = tool # type: ignore[no-any-unimported] + + if deps is not None: + ctx = RunContext( + deps=deps, + retry=pydantic_ai_tool.max_retries, # TODO: check what to do with this + messages=[], # TODO: check what to do with this + tool_name=pydantic_ai_tool.name, + ) + func = PydanticAIInteroperability.inject_params(f=pydantic_ai_tool.function, ctx=ctx) + else: + func = pydantic_ai_tool.function + + return Tool( + name=pydantic_ai_tool.name, + description=pydantic_ai_tool.description, + func=func, + ) diff --git a/setup.py b/setup.py index 88e6a62e96..63cade834a 100644 --- a/setup.py +++ b/setup.py @@ -71,6 +71,7 @@ interop_crewai = ["crewai[tools]>=0.86,<1; python_version>='3.10' and python_version<'3.13'"] interop_langchain = ["langchain-community>=0.3.12,<1; python_version>='3.9'"] +interop_pydantic_ai = ["pydantic-ai>=0.0.13,<1; python_version>='3.9'"] if current_os in ["Windows", "Darwin"]: retrieve_chat_pgvector.extend(["psycopg[binary]>=3.1.18"]) @@ -127,7 +128,8 @@ "bedrock": ["boto3>=1.34.149"], "interop-crewai": interop_crewai, "interop-langchain": interop_langchain, - "interop": interop_crewai + interop_langchain, + "interop-pydantic-ai": interop_pydantic_ai, + "interop": interop_crewai + interop_langchain + interop_pydantic_ai, "neo4j": neo4j, } diff --git a/setup_ag2.py b/setup_ag2.py index f0015dda36..0b8a9dfec7 100644 --- a/setup_ag2.py +++ b/setup_ag2.py @@ -56,6 +56,7 @@ "bedrock": ["pyautogen[bedrock]==" + __version__], "interop-crewai": ["pyautogen[interop-crewai]==" + __version__], "interop-langchain": ["pyautogen[interop-langchain]==" + __version__], + "interop-pydantic-ai": ["pyautogen[interop-pydantic-ai]==" + __version__], "interop": ["pyautogen[interop]==" + __version__], "neo4j": ["pyautogen[neo4j]==" + __version__], }, diff --git a/setup_autogen.py b/setup_autogen.py index 520b7294d5..93690e4bea 100644 --- a/setup_autogen.py +++ b/setup_autogen.py @@ -56,6 +56,7 @@ "bedrock": ["pyautogen[bedrock]==" + __version__], "interop-crewai": ["pyautogen[interop-crewai]==" + __version__], "interop-langchain": ["pyautogen[interop-langchain]==" + __version__], + "interop-pydantic-ai": ["pyautogen[interop-pydantic-ai]==" + __version__], "interop": ["pyautogen[interop]==" + __version__], "neo4j": ["pyautogen[neo4j]==" + __version__], }, diff --git a/test/interop/pydantic_ai/__init__.py b/test/interop/pydantic_ai/__init__.py new file mode 100644 index 0000000000..bcd5401d54 --- /dev/null +++ b/test/interop/pydantic_ai/__init__.py @@ -0,0 +1,3 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/test/interop/pydantic_ai/test_pydantic_ai.py b/test/interop/pydantic_ai/test_pydantic_ai.py new file mode 100644 index 0000000000..feb5192162 --- /dev/null +++ b/test/interop/pydantic_ai/test_pydantic_ai.py @@ -0,0 +1,170 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +import os +import random +import sys +import unittest +from inspect import signature +from typing import Any, Dict, Optional + +import pytest +from conftest import reason, skip_openai +from pydantic import BaseModel + +from autogen import AssistantAgent, UserProxyAgent +from autogen.interop import Interoperable + +if sys.version_info >= (3, 9): + from pydantic_ai import RunContext + from pydantic_ai.tools import Tool as PydanticAITool + + from autogen.interop.pydantic_ai import PydanticAIInteroperability +else: + RunContext = unittest.mock.MagicMock() + PydanticAITool = unittest.mock.MagicMock() + PydanticAIInteroperability = unittest.mock.MagicMock() + + +# skip if python version is not >= 3.9 +@pytest.mark.skipif( + sys.version_info < (3, 9), reason="Only Python 3.9 and above are supported for LangchainInteroperability" +) +class TestPydanticAIInteroperabilityWithotContext: + @pytest.fixture(autouse=True) + def setup(self) -> None: + def roll_dice() -> str: + """Roll a six-sided dice and return the result.""" + return str(random.randint(1, 6)) + + self.pydantic_ai_interop = PydanticAIInteroperability() + pydantic_ai_tool = PydanticAITool(roll_dice) + self.tool = self.pydantic_ai_interop.convert_tool(pydantic_ai_tool) + + def test_type_checks(self) -> None: + # mypy should fail if the type checks are not correct + interop: Interoperable = self.pydantic_ai_interop + # runtime check + assert isinstance(interop, Interoperable) + + def test_init(self) -> None: + assert isinstance(self.pydantic_ai_interop, Interoperable) + + def test_convert_tool(self) -> None: + assert self.tool.name == "roll_dice" + assert self.tool.description == "Roll a six-sided dice and return the result." + assert self.tool.func() in ["1", "2", "3", "4", "5", "6"] + + @pytest.mark.skipif(skip_openai, reason=reason) + def test_with_llm(self) -> None: + config_list = [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}] + user_proxy = UserProxyAgent( + name="User", + human_input_mode="NEVER", + ) + + chatbot = AssistantAgent( + name="chatbot", + llm_config={"config_list": config_list}, + ) + + self.tool.register_for_execution(user_proxy) + self.tool.register_for_llm(chatbot) + + user_proxy.initiate_chat(recipient=chatbot, message="roll a dice", max_turns=2) + + for message in user_proxy.chat_messages[chatbot]: + if "tool_responses" in message: + assert message["tool_responses"][0]["content"] in ["1", "2", "3", "4", "5", "6"] + return + + assert False, "No tool response found in chat messages" + + +class TestPydanticAIInteroperabilityWithContext: + @pytest.fixture(autouse=True) + def setup(self) -> None: + class Player(BaseModel): + name: str + age: int + + def get_player(ctx: RunContext[Player], additional_info: Optional[str] = None) -> str: # type: ignore[valid-type] + """Get the player's name. + + Args: + additional_info: Additional information which can be used. + """ + return f"Name: {ctx.deps.name}, Age: {ctx.deps.age}, Additional info: {additional_info}" # type: ignore[attr-defined] + + self.pydantic_ai_interop = PydanticAIInteroperability() + pydantic_ai_tool = PydanticAITool(get_player, takes_ctx=True) + player = Player(name="Luka", age=25) + self.tool = self.pydantic_ai_interop.convert_tool(tool=pydantic_ai_tool, deps=player) + + def test_dependency_injection(self) -> None: + def f( + city: str, + date: str, + ctx: int, + ) -> str: + return f"{city} {date} {ctx}" + + ctx = 123 + g = PydanticAIInteroperability.inject_params(f=f, ctx=ctx) + assert list(signature(g).parameters.keys()) == ["city", "date"] + kwargs: Dict[str, Any] = {"city": "Zagreb", "date": "2021-01-01"} + assert g(**kwargs) == "Zagreb 2021-01-01 123" + + def test_signature(self) -> None: + assert str(self.tool.func.__signature__) == "(additional_info: Optional[str] = None) -> str" + + @pytest.mark.skipif(skip_openai, reason=reason) + def test_with_llm(self) -> None: + config_list = [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}] + user_proxy = UserProxyAgent( + name="User", + human_input_mode="NEVER", + ) + + chatbot = AssistantAgent( + name="chatbot", + llm_config={"config_list": config_list}, + ) + + self.tool.register_for_execution(user_proxy) + self.tool.register_for_llm(chatbot) + + expected_tools = [ + { + "type": "function", + "function": { + "description": "Get the player's name.", + "name": "get_player", + "parameters": { + "type": "object", + "properties": { + "additional_info": { + "anyOf": [{"type": "string"}, {"type": "null"}], + "default": None, + "description": "additional_info", + } + }, + "required": [], + }, + }, + } + ] + + assert chatbot.llm_config["tools"] == expected_tools # type: ignore[index] + + user_proxy.initiate_chat( + recipient=chatbot, message="Get player, for additional information use 'goal keeper'", max_turns=3 + ) + + for message in user_proxy.chat_messages[chatbot]: + if "tool_responses" in message: + assert message["tool_responses"][0]["content"] == "Name: Luka, Age: 25, Additional info: goal keeper" + return + + assert False, "No tool response found in chat messages" From 7a7b33662d63b59a812c6e12a5a79cc4967295a6 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Wed, 18 Dec 2024 09:36:06 +0100 Subject: [PATCH 35/70] Override register_for_llm function for PydanticAITool --- autogen/agentchat/conversable_agent.py | 2 +- autogen/interop/pydantic_ai/pydantic_ai.py | 7 +- autogen/tools/__init__.py | 3 +- autogen/tools/pydantic_ai_tool.py | 29 ++ notebook/pydantic_ai.ipynb | 362 +++++------------- .../tools_langchain_tools_integration.ipynb | 2 +- test/interop/pydantic_ai/test_pydantic_ai.py | 40 +- 7 files changed, 159 insertions(+), 286 deletions(-) create mode 100644 autogen/tools/pydantic_ai_tool.py diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py index ffd6923721..b2f22ce9c5 100644 --- a/autogen/agentchat/conversable_agent.py +++ b/autogen/agentchat/conversable_agent.py @@ -2600,7 +2600,7 @@ def update_function_signature(self, func_sig: Union[str, Dict], is_remove: None) self.client = OpenAIWrapper(**self.llm_config) - def update_tool_signature(self, tool_sig: Union[str, Dict], is_remove: None): + def update_tool_signature(self, tool_sig: Union[str, Dict], is_remove: bool): """update a tool_signature in the LLM configuration for tool_call. Args: diff --git a/autogen/interop/pydantic_ai/pydantic_ai.py b/autogen/interop/pydantic_ai/pydantic_ai.py index 2e77d6ef71..147d47481b 100644 --- a/autogen/interop/pydantic_ai/pydantic_ai.py +++ b/autogen/interop/pydantic_ai/pydantic_ai.py @@ -10,7 +10,7 @@ from pydantic_ai import RunContext from pydantic_ai.tools import Tool as PydanticAITool -from ...tools import Tool +from ...tools import PydanticAITool as AG2PydanticAITool from ..interoperability import Interoperable __all__ = ["PydanticAIInteroperability"] @@ -31,7 +31,7 @@ def wrapper(*args: Any, **kwargs: Any) -> Any: return wrapper - def convert_tool(self, tool: Any, deps: Any = None) -> Tool: + def convert_tool(self, tool: Any, deps: Any = None) -> AG2PydanticAITool: if not isinstance(tool, PydanticAITool): raise ValueError(f"Expected an instance of `pydantic_ai.tools.Tool`, got {type(tool)}") @@ -49,8 +49,9 @@ def convert_tool(self, tool: Any, deps: Any = None) -> Tool: else: func = pydantic_ai_tool.function - return Tool( + return AG2PydanticAITool( name=pydantic_ai_tool.name, description=pydantic_ai_tool.description, func=func, + parameters_json_schema=pydantic_ai_tool._parameters_json_schema, ) diff --git a/autogen/tools/__init__.py b/autogen/tools/__init__.py index 3451ac3111..d787ae1a60 100644 --- a/autogen/tools/__init__.py +++ b/autogen/tools/__init__.py @@ -1,3 +1,4 @@ +from .pydantic_ai_tool import PydanticAITool from .tool import Tool -__all__ = ["Tool"] +__all__ = ["PydanticAITool", "Tool"] diff --git a/autogen/tools/pydantic_ai_tool.py b/autogen/tools/pydantic_ai_tool.py new file mode 100644 index 0000000000..5c999eba3a --- /dev/null +++ b/autogen/tools/pydantic_ai_tool.py @@ -0,0 +1,29 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +from typing import Any, Callable, Dict + +from autogen.agentchat.conversable_agent import ConversableAgent + +from .tool import Tool + +__all__ = ["PydanticAITool"] + + +class PydanticAITool(Tool): + def __init__( + self, name: str, description: str, func: Callable[..., Any], parameters_json_schema: Dict[str, Any] + ) -> None: + super().__init__(name, description, func) + self._func_schema = { + "type": "function", + "function": { + "name": name, + "description": description, + "parameters": parameters_json_schema, + }, + } + + def register_for_llm(self, agent: ConversableAgent) -> None: + agent.update_tool_signature(self._func_schema, is_remove=False) diff --git a/notebook/pydantic_ai.ipynb b/notebook/pydantic_ai.ipynb index 8d38ffe936..5451c33126 100644 --- a/notebook/pydantic_ai.ipynb +++ b/notebook/pydantic_ai.ipynb @@ -37,38 +37,18 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'5'" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "rool_dice_tool.function()" ] }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "roll_dice\n", - "Roll a six-sided dice and return the result.\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "print(rool_dice_tool.name)\n", "print(rool_dice_tool.description)" @@ -76,41 +56,18 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'properties': {'name': {'title': 'Name', 'type': 'string'}},\n", - " 'required': ['name'],\n", - " 'type': 'object',\n", - " 'additionalProperties': False}" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "rool_dice_tool._parameters_json_schema" ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "foobar\n", - "Get me foobar.\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from typing import Optional\n", "\n", @@ -134,32 +91,9 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'properties': {'a': {'description': 'apple pie',\n", - " 'title': 'A',\n", - " 'type': 'integer'},\n", - " 'b': {'description': 'banana cake', 'title': 'B', 'type': 'string'},\n", - " 'c': {'anyOf': [{'additionalProperties': {'items': {'type': 'number'},\n", - " 'type': 'array'},\n", - " 'type': 'object'},\n", - " {'type': 'null'}],\n", - " 'description': 'carrot smoothie',\n", - " 'title': 'C'}},\n", - " 'required': ['a', 'b', 'c'],\n", - " 'type': 'object',\n", - " 'additionalProperties': False}" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "foobar_tool._parameters_json_schema" ] @@ -222,20 +156,9 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "RunResult(_all_messages=[ModelRequest(parts=[UserPromptPart(content='Get players name', timestamp=datetime.datetime(2024, 12, 17, 15, 1, 58, 163148, tzinfo=datetime.timezone.utc), part_kind='user-prompt')], kind='request'), ModelResponse(parts=[ToolCallPart(tool_name='get_player_name', args=ArgsJson(args_json='{}'), tool_call_id='call_410yrIwckDRCr9wSF0GXy8eL', part_kind='tool-call')], timestamp=datetime.datetime(2024, 12, 17, 15, 1, 58, tzinfo=datetime.timezone.utc), kind='response'), ModelRequest(parts=[ToolReturnPart(tool_name='get_player_name', content='Anne', tool_call_id='call_410yrIwckDRCr9wSF0GXy8eL', timestamp=datetime.datetime(2024, 12, 17, 15, 1, 59, 95607, tzinfo=datetime.timezone.utc), part_kind='tool-return')], kind='request'), ModelResponse(parts=[TextPart(content=\"The player's name is Anne.\", part_kind='text')], timestamp=datetime.datetime(2024, 12, 17, 15, 1, 59, tzinfo=datetime.timezone.utc), kind='response')], _new_message_index=0, data=\"The player's name is Anne.\", _cost=Cost(request_tokens=101, response_tokens=18, total_tokens=119, details={'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0, 'cached_tokens': 0}))" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "result = agent_a.run_sync(\"Get players name\", deps=\"Anne\")\n", "result" @@ -243,23 +166,9 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[ModelRequest(parts=[UserPromptPart(content='Get players name', timestamp=datetime.datetime(2024, 12, 17, 15, 1, 58, 163148, tzinfo=datetime.timezone.utc), part_kind='user-prompt')], kind='request'),\n", - " ModelResponse(parts=[ToolCallPart(tool_name='get_player_name', args=ArgsJson(args_json='{}'), tool_call_id='call_410yrIwckDRCr9wSF0GXy8eL', part_kind='tool-call')], timestamp=datetime.datetime(2024, 12, 17, 15, 1, 58, tzinfo=datetime.timezone.utc), kind='response'),\n", - " ModelRequest(parts=[ToolReturnPart(tool_name='get_player_name', content='Anne', tool_call_id='call_410yrIwckDRCr9wSF0GXy8eL', timestamp=datetime.datetime(2024, 12, 17, 15, 1, 59, 95607, tzinfo=datetime.timezone.utc), part_kind='tool-return')], kind='request'),\n", - " ModelResponse(parts=[TextPart(content=\"The player's name is Anne.\", part_kind='text')], timestamp=datetime.datetime(2024, 12, 17, 15, 1, 59, tzinfo=datetime.timezone.utc), kind='response')]" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "result.all_messages()" ] @@ -306,19 +215,9 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "get_player\n", - "Get the player's name.\n", - "{'properties': {'additional_info': {'anyOf': [{'type': 'string'}, {'type': 'null'}], 'description': 'Additional information which can be used.', 'title': 'Additional Info'}}, 'required': ['additional_info'], 'type': 'object', 'additionalProperties': False}\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "print(get_player_tool.name)\n", "print(get_player_tool.description)\n", @@ -327,21 +226,9 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[ModelRequest(parts=[UserPromptPart(content='Get player', timestamp=datetime.datetime(2024, 12, 17, 15, 1, 59, 708795, tzinfo=datetime.timezone.utc), part_kind='user-prompt')], kind='request'),\n", - " ModelResponse(parts=[TextPart(content=\"Could you please provide any additional information or context regarding the player you're interested in? This will help me deliver the most relevant details for you.\", part_kind='text')], timestamp=datetime.datetime(2024, 12, 17, 15, 2, tzinfo=datetime.timezone.utc), kind='response')]" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "agent_b = Agent(\n", " \"openai:gpt-4o\",\n", @@ -406,40 +293,18 @@ }, { "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - " str>" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "f_injected.__signature__" ] }, { "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'Name: Luka, Age: 25, Additional info: Hello'" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "f_injected(additional_info=\"Hello\")" ] @@ -482,7 +347,61 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Dict\n", + "\n", + "\n", + "def create_function_schema(name: str, description: str, parameters: Dict[str, Any]) -> Dict[str, Any]:\n", + " # parameters are:\n", + " # {'properties': {'additional_info': {'anyOf': [{'type': 'string'},\n", + " # {'type': 'null'}],\n", + " # 'description': 'Additional information which can be used.',\n", + " # 'title': 'Additional Info'}},\n", + " # 'required': ['additional_info'],\n", + " # 'type': 'object',\n", + " # 'additionalProperties': False}\n", + "\n", + " # response should be:\n", + " # {'type': 'function', 'function': {'description': \"Get the player's name.\", 'name': 'get_player', 'parameters': {'type': 'object', 'properties': {'additional_info': {'anyOf': [{'type': 'string'}, {'type': 'null'}], 'default': None, 'description': 'additional_info'}}, 'required': []}}\n", + " return {\n", + " \"type\": \"function\",\n", + " \"function\": {\n", + " \"name\": name,\n", + " \"description\": description,\n", + " \"parameters\": parameters,\n", + " },\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "get_player_tool._parameters_json_schema" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "function_schema = create_function_schema(\n", + " name=get_player_tool.name,\n", + " description=get_player_tool.description,\n", + " parameters=get_player_tool._parameters_json_schema,\n", + ")\n", + "function_schema" + ] + }, + { + "cell_type": "code", + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -493,112 +412,29 @@ }, { "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - " str>" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "user_proxy.register_for_execution(name=tool.name)(f_injected_ctx)\n", - "chatbot.register_for_llm(description=tool.description, name=tool.name)(f_injected_ctx)" + "# chatbot.register_for_llm(description=tool.description, name=tool.name)(f_injected_ctx)\n", + "chatbot.update_tool_signature(function_schema, is_remove=False)" ] }, { "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'type': 'function',\n", - " 'function': {'description': \"Get the player's name.\",\n", - " 'name': 'get_player',\n", - " 'parameters': {'type': 'object',\n", - " 'properties': {'additional_info': {'anyOf': [{'type': 'string'},\n", - " {'type': 'null'}],\n", - " 'default': None,\n", - " 'description': 'additional_info'}},\n", - " 'required': []}}}]" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "chatbot.llm_config[\"tools\"]" ] }, { "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[33mUser\u001b[0m (to chatbot):\n", - "\n", - "Get player, for additional information use 'goal keeper'\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mchatbot\u001b[0m (to User):\n", - "\n", - "\u001b[32m***** Suggested tool call (call_S1wA3FAaTLFAt5aLv19xwOXJ): get_player *****\u001b[0m\n", - "Arguments: \n", - "{\"additional_info\":\"goal keeper\"}\n", - "\u001b[32m***************************************************************************\u001b[0m\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[35m\n", - ">>>>>>>> EXECUTING FUNCTION get_player...\u001b[0m\n", - "\u001b[33mUser\u001b[0m (to chatbot):\n", - "\n", - "\u001b[32m***** Response from calling tool (call_S1wA3FAaTLFAt5aLv19xwOXJ) *****\u001b[0m\n", - "Name: Luka, Age: 25, Additional info: goal keeper\n", - "\u001b[32m**********************************************************************\u001b[0m\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mchatbot\u001b[0m (to User):\n", - "\n", - "The player's name is Luka, aged 25, and is a goal keeper. TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mUser\u001b[0m (to chatbot):\n", - "\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mchatbot\u001b[0m (to User):\n", - "\n", - "It seems like there was no follow-up request. If there's anything else you need, feel free to ask! TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n" - ] - }, - { - "data": { - "text/plain": [ - "ChatResult(chat_id=None, chat_history=[{'content': \"Get player, for additional information use 'goal keeper'\", 'role': 'assistant', 'name': 'User'}, {'tool_calls': [{'id': 'call_S1wA3FAaTLFAt5aLv19xwOXJ', 'function': {'arguments': '{\"additional_info\":\"goal keeper\"}', 'name': 'get_player'}, 'type': 'function'}], 'content': None, 'role': 'assistant'}, {'content': 'Name: Luka, Age: 25, Additional info: goal keeper', 'tool_responses': [{'tool_call_id': 'call_S1wA3FAaTLFAt5aLv19xwOXJ', 'role': 'tool', 'content': 'Name: Luka, Age: 25, Additional info: goal keeper'}], 'role': 'tool', 'name': 'User'}, {'content': \"The player's name is Luka, aged 25, and is a goal keeper. TERMINATE\", 'role': 'user', 'name': 'chatbot'}, {'content': '', 'role': 'assistant', 'name': 'User'}, {'content': \"It seems like there was no follow-up request. If there's anything else you need, feel free to ask! TERMINATE\", 'role': 'user', 'name': 'chatbot'}], summary=\"It seems like there was no follow-up request. If there's anything else you need, feel free to ask! \", cost={'usage_including_cached_inference': {'total_cost': 0.0047675, 'gpt-4o-2024-08-06': {'cost': 0.0047675, 'prompt_tokens': 1667, 'completion_tokens': 60, 'total_tokens': 1727}}, 'usage_excluding_cached_inference': {'total_cost': 0}}, human_input=[])" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "user_proxy.initiate_chat(\n", " recipient=chatbot, message=\"Get player, for additional information use 'goal keeper'\", max_turns=3\n", diff --git a/notebook/tools_langchain_tools_integration.ipynb b/notebook/tools_langchain_tools_integration.ipynb index 3fb4d68594..8610d2d00e 100644 --- a/notebook/tools_langchain_tools_integration.ipynb +++ b/notebook/tools_langchain_tools_integration.ipynb @@ -112,7 +112,7 @@ "ag2_tool = langchain_interop.convert_tool(langchain_tool)\n", "\n", "ag2_tool.register_for_execution(user_proxy)\n", - "ag2_tool.register_for_llm(chatbot)\n" + "ag2_tool.register_for_llm(chatbot)" ] }, { diff --git a/test/interop/pydantic_ai/test_pydantic_ai.py b/test/interop/pydantic_ai/test_pydantic_ai.py index feb5192162..828a1236d2 100644 --- a/test/interop/pydantic_ai/test_pydantic_ai.py +++ b/test/interop/pydantic_ai/test_pydantic_ai.py @@ -116,41 +116,31 @@ def f( kwargs: Dict[str, Any] = {"city": "Zagreb", "date": "2021-01-01"} assert g(**kwargs) == "Zagreb 2021-01-01 123" - def test_signature(self) -> None: - assert str(self.tool.func.__signature__) == "(additional_info: Optional[str] = None) -> str" - - @pytest.mark.skipif(skip_openai, reason=reason) - def test_with_llm(self) -> None: + def test_expected_tools(self) -> None: config_list = [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}] - user_proxy = UserProxyAgent( - name="User", - human_input_mode="NEVER", - ) - chatbot = AssistantAgent( name="chatbot", llm_config={"config_list": config_list}, ) - - self.tool.register_for_execution(user_proxy) self.tool.register_for_llm(chatbot) expected_tools = [ { "type": "function", "function": { - "description": "Get the player's name.", "name": "get_player", + "description": "Get the player's name.", "parameters": { - "type": "object", "properties": { "additional_info": { "anyOf": [{"type": "string"}, {"type": "null"}], - "default": None, - "description": "additional_info", + "description": "Additional information which can be used.", + "title": "Additional Info", } }, - "required": [], + "required": ["additional_info"], + "type": "object", + "additionalProperties": False, }, }, } @@ -158,6 +148,22 @@ def test_with_llm(self) -> None: assert chatbot.llm_config["tools"] == expected_tools # type: ignore[index] + @pytest.mark.skipif(skip_openai, reason=reason) + def test_with_llm(self) -> None: + config_list = [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}] + user_proxy = UserProxyAgent( + name="User", + human_input_mode="NEVER", + ) + + chatbot = AssistantAgent( + name="chatbot", + llm_config={"config_list": config_list}, + ) + + self.tool.register_for_execution(user_proxy) + self.tool.register_for_llm(chatbot) + user_proxy.initiate_chat( recipient=chatbot, message="Get player, for additional information use 'goal keeper'", max_turns=3 ) From 17409857361d20ff85fea9bd85125c11fe016d64 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Wed, 18 Dec 2024 11:45:25 +0100 Subject: [PATCH 36/70] Add max_retries to pydantic ai tools interop --- autogen/interop/pydantic_ai/pydantic_ai.py | 45 +++++++++++++++---- test/interop/pydantic_ai/test_pydantic_ai.py | 46 +++++++++++++------- 2 files changed, 67 insertions(+), 24 deletions(-) diff --git a/autogen/interop/pydantic_ai/pydantic_ai.py b/autogen/interop/pydantic_ai/pydantic_ai.py index 147d47481b..52adba002f 100644 --- a/autogen/interop/pydantic_ai/pydantic_ai.py +++ b/autogen/interop/pydantic_ai/pydantic_ai.py @@ -5,7 +5,7 @@ from functools import wraps from inspect import signature -from typing import Any, Callable +from typing import Any, Callable, Optional from pydantic_ai import RunContext from pydantic_ai.tools import Tool as PydanticAITool @@ -18,14 +18,37 @@ class PydanticAIInteroperability(Interoperable): @staticmethod - def inject_params(f: Callable[..., Any], ctx: Any) -> Callable[..., Any]: + def inject_params( # type: ignore[no-any-unimported] + ctx: Optional[RunContext[Any]], + tool: PydanticAITool, + ) -> Callable[..., Any]: + max_retries = tool.max_retries if tool.max_retries is not None else 1 + f = tool.function + @wraps(f) def wrapper(*args: Any, **kwargs: Any) -> Any: - kwargs.pop("ctx", None) - return f(**kwargs, ctx=ctx) + if tool.current_retry >= max_retries: + raise ValueError(f"{tool.name} failed after {max_retries} retries") + + try: + if ctx is not None: + kwargs.pop("ctx", None) + ctx.retry = tool.current_retry + result = f(**kwargs, ctx=ctx) + else: + result = f(**kwargs) + tool.current_retry = 0 + except Exception as e: + tool.current_retry += 1 + raise e + + return result sig = signature(f) - new_params = [param for name, param in sig.parameters.items() if name != "ctx"] + if ctx is not None: + new_params = [param for name, param in sig.parameters.items() if name != "ctx"] + else: + new_params = list(sig.parameters.values()) wrapper.__signature__ = sig.replace(parameters=new_params) # type: ignore[attr-defined] @@ -41,13 +64,17 @@ def convert_tool(self, tool: Any, deps: Any = None) -> AG2PydanticAITool: if deps is not None: ctx = RunContext( deps=deps, - retry=pydantic_ai_tool.max_retries, # TODO: check what to do with this - messages=[], # TODO: check what to do with this + retry=0, + messages=None, # TODO: check what to do with this tool_name=pydantic_ai_tool.name, ) - func = PydanticAIInteroperability.inject_params(f=pydantic_ai_tool.function, ctx=ctx) else: - func = pydantic_ai_tool.function + ctx = None + + func = PydanticAIInteroperability.inject_params( + ctx=ctx, + tool=pydantic_ai_tool, + ) return AG2PydanticAITool( name=pydantic_ai_tool.name, diff --git a/test/interop/pydantic_ai/test_pydantic_ai.py b/test/interop/pydantic_ai/test_pydantic_ai.py index 828a1236d2..634cbc4beb 100644 --- a/test/interop/pydantic_ai/test_pydantic_ai.py +++ b/test/interop/pydantic_ai/test_pydantic_ai.py @@ -39,7 +39,7 @@ def roll_dice() -> str: return str(random.randint(1, 6)) self.pydantic_ai_interop = PydanticAIInteroperability() - pydantic_ai_tool = PydanticAITool(roll_dice) + pydantic_ai_tool = PydanticAITool(roll_dice, max_retries=3) self.tool = self.pydantic_ai_interop.convert_tool(pydantic_ai_tool) def test_type_checks(self) -> None: @@ -82,6 +82,36 @@ def test_with_llm(self) -> None: assert False, "No tool response found in chat messages" +class TestPydanticAIInteroperabilityDependencyInjection: + @pytest.fixture(autouse=True) + def setup(self) -> None: + def f( + ctx: RunContext[int], # type: ignore[valid-type] + city: str, + date: str, + ) -> str: + """Random function for testing.""" + return f"{city} {date} {ctx.deps}" # type: ignore[attr-defined] + + self.func = f + + def test_dependency_injection(self) -> None: + ctx = RunContext( + deps=123, + retry=0, + messages=None, + tool_name=self.func.__name__, + ) + pydantic_ai_tool = PydanticAITool(self.func, takes_ctx=True) + g = PydanticAIInteroperability.inject_params( + ctx=ctx, + tool=pydantic_ai_tool, + ) + assert list(signature(g).parameters.keys()) == ["city", "date"] + kwargs: Dict[str, Any] = {"city": "Zagreb", "date": "2021-01-01"} + assert g(**kwargs) == "Zagreb 2021-01-01 123" + + class TestPydanticAIInteroperabilityWithContext: @pytest.fixture(autouse=True) def setup(self) -> None: @@ -102,20 +132,6 @@ def get_player(ctx: RunContext[Player], additional_info: Optional[str] = None) - player = Player(name="Luka", age=25) self.tool = self.pydantic_ai_interop.convert_tool(tool=pydantic_ai_tool, deps=player) - def test_dependency_injection(self) -> None: - def f( - city: str, - date: str, - ctx: int, - ) -> str: - return f"{city} {date} {ctx}" - - ctx = 123 - g = PydanticAIInteroperability.inject_params(f=f, ctx=ctx) - assert list(signature(g).parameters.keys()) == ["city", "date"] - kwargs: Dict[str, Any] = {"city": "Zagreb", "date": "2021-01-01"} - assert g(**kwargs) == "Zagreb 2021-01-01 123" - def test_expected_tools(self) -> None: config_list = [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}] chatbot = AssistantAgent( From 48fece4168a8b69f2d1c5ee627c0e9c6afe4c74a Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Wed, 18 Dec 2024 12:18:43 +0100 Subject: [PATCH 37/70] Add test_dependency_injection_with_retry --- test/interop/pydantic_ai/test_pydantic_ai.py | 43 ++++++++++++++++---- 1 file changed, 36 insertions(+), 7 deletions(-) diff --git a/test/interop/pydantic_ai/test_pydantic_ai.py b/test/interop/pydantic_ai/test_pydantic_ai.py index 634cbc4beb..4bf3304366 100644 --- a/test/interop/pydantic_ai/test_pydantic_ai.py +++ b/test/interop/pydantic_ai/test_pydantic_ai.py @@ -83,8 +83,8 @@ def test_with_llm(self) -> None: class TestPydanticAIInteroperabilityDependencyInjection: - @pytest.fixture(autouse=True) - def setup(self) -> None: + + def test_dependency_injection(self) -> None: def f( ctx: RunContext[int], # type: ignore[valid-type] city: str, @@ -93,16 +93,13 @@ def f( """Random function for testing.""" return f"{city} {date} {ctx.deps}" # type: ignore[attr-defined] - self.func = f - - def test_dependency_injection(self) -> None: ctx = RunContext( deps=123, retry=0, messages=None, - tool_name=self.func.__name__, + tool_name=f.__name__, ) - pydantic_ai_tool = PydanticAITool(self.func, takes_ctx=True) + pydantic_ai_tool = PydanticAITool(f, takes_ctx=True) g = PydanticAIInteroperability.inject_params( ctx=ctx, tool=pydantic_ai_tool, @@ -111,6 +108,38 @@ def test_dependency_injection(self) -> None: kwargs: Dict[str, Any] = {"city": "Zagreb", "date": "2021-01-01"} assert g(**kwargs) == "Zagreb 2021-01-01 123" + def test_dependency_injection_with_retry(self) -> None: + def f( + ctx: RunContext[int], # type: ignore[valid-type] + city: str, + date: str, + ) -> str: + """Random function for testing.""" + raise ValueError("Retry") + + ctx = RunContext( + deps=123, + retry=0, + messages=None, + tool_name=f.__name__, + ) + + pydantic_ai_tool = PydanticAITool(f, takes_ctx=True, max_retries=3) + g = PydanticAIInteroperability.inject_params( + ctx=ctx, + tool=pydantic_ai_tool, + ) + + for i in range(3): + with pytest.raises(ValueError, match="Retry"): + g(city="Zagreb", date="2021-01-01") + assert pydantic_ai_tool.current_retry == i + 1 + assert ctx.retry == i + + with pytest.raises(ValueError, match="f failed after 3 retries"): + g(city="Zagreb", date="2021-01-01") + assert pydantic_ai_tool.current_retry == 3 + class TestPydanticAIInteroperabilityWithContext: @pytest.fixture(autouse=True) From b045ab1517bdaa35b91490ec87c6cb878266d5ef Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Wed, 18 Dec 2024 12:50:36 +0100 Subject: [PATCH 38/70] Update PydanticAIInteroperability comments --- autogen/interop/pydantic_ai/pydantic_ai.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/autogen/interop/pydantic_ai/pydantic_ai.py b/autogen/interop/pydantic_ai/pydantic_ai.py index 52adba002f..27a146704c 100644 --- a/autogen/interop/pydantic_ai/pydantic_ai.py +++ b/autogen/interop/pydantic_ai/pydantic_ai.py @@ -65,7 +65,9 @@ def convert_tool(self, tool: Any, deps: Any = None) -> AG2PydanticAITool: ctx = RunContext( deps=deps, retry=0, - messages=None, # TODO: check what to do with this + # All messages send to or returned by a model. + # This is mostly used on pydantic_ai Agent level. + messages=None, # TODO: check in the future if this is needed on Tool level tool_name=pydantic_ai_tool.name, ) else: From 59c0944b66f36584bdb8a38d484ad06347f50d3e Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Wed, 18 Dec 2024 12:51:28 +0100 Subject: [PATCH 39/70] new Interoperability class added --- autogen/interop/__init__.py | 5 +- autogen/interop/crewai/crewai.py | 2 +- autogen/interop/helpers.py | 55 ++++++++++++++++++ autogen/interop/interoperability.py | 37 ++++++++++-- autogen/interop/interoperable.py | 14 +++++ autogen/interop/langchain/langchain.py | 2 +- test/interop/test_helpers.py | 62 ++++++++++++++++++++ test/interop/test_interoperability.py | 78 +++++++++++++++++++++++++- test/interop/test_interoperable.py | 9 +++ 9 files changed, 252 insertions(+), 12 deletions(-) create mode 100644 autogen/interop/helpers.py create mode 100644 autogen/interop/interoperable.py create mode 100644 test/interop/test_helpers.py create mode 100644 test/interop/test_interoperable.py diff --git a/autogen/interop/__init__.py b/autogen/interop/__init__.py index b5dc8c9521..90c5f92d7b 100644 --- a/autogen/interop/__init__.py +++ b/autogen/interop/__init__.py @@ -2,6 +2,7 @@ # # SPDX-License-Identifier: Apache-2.0 -from .interoperability import Interoperable +from .interoperability import Interoperability +from .interoperable import Interoperable -__all__ = ["Interoperable"] +__all__ = ["Interoperable", "Interoperability"] diff --git a/autogen/interop/crewai/crewai.py b/autogen/interop/crewai/crewai.py index 98df36cf05..c391b22888 100644 --- a/autogen/interop/crewai/crewai.py +++ b/autogen/interop/crewai/crewai.py @@ -8,7 +8,7 @@ from crewai.tools import BaseTool as CrewAITool from ...tools import Tool -from ..interoperability import Interoperable +from ..interoperable import Interoperable __all__ = ["CrewAIInteroperability"] diff --git a/autogen/interop/helpers.py b/autogen/interop/helpers.py new file mode 100644 index 0000000000..5ec24afd9b --- /dev/null +++ b/autogen/interop/helpers.py @@ -0,0 +1,55 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 +# + +import importlib +import inspect +import logging +import pkgutil +import sys +from typing import Any, Dict, List, Set, Type + +from .interoperable import Interoperable + +logger = logging.getLogger(__name__) + + +def import_submodules(package_name: str) -> List[str]: + package = importlib.import_module(package_name) + imported_modules: List[str] = [] + for loader, module_name, is_pkg in pkgutil.walk_packages(package.__path__, package.__name__ + "."): + try: + importlib.import_module(module_name) + + imported_modules.append(module_name) + except Exception as e: + logger.info(f"Error importing {module_name}, most likely perfectly fine: {e}") + + return imported_modules + + +def find_classes_implementing_protocol(imported_modules: List[str], protocol: Type[Any]) -> List[Type[Any]]: + implementing_classes: Set[Type[Any]] = set() + for module in imported_modules: + for _, obj in inspect.getmembers(sys.modules[module], inspect.isclass): + if issubclass(obj, protocol) and obj is not protocol: + implementing_classes.add(obj) + + return list(implementing_classes) + + +def get_all_interoperability_classes() -> Dict[str, Type[Interoperable]]: + imported_modules = import_submodules("autogen.interop") + classes = find_classes_implementing_protocol(imported_modules, Interoperable) + + # check that all classes finish with 'Interoperability' + for cls in classes: + if not cls.__name__.endswith("Interoperability"): + raise RuntimeError(f"Class {cls} does not end with 'Interoperability'") + + retval = { + cls.__name__.split("Interoperability")[0].lower(): cls for cls in classes if cls.__name__ != "Interoperability" + } + + return retval diff --git a/autogen/interop/interoperability.py b/autogen/interop/interoperability.py index 436e75bb43..b68a8ce4f8 100644 --- a/autogen/interop/interoperability.py +++ b/autogen/interop/interoperability.py @@ -1,12 +1,39 @@ # Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai # # SPDX-License-Identifier: Apache-2.0 - -from typing import Any, Protocol, runtime_checkable +from typing import Any, Dict, List, Type from ..tools import Tool +from .helpers import get_all_interoperability_classes +from .interoperable import Interoperable + + +class Interoperability: + _interoperability_classes: Dict[str, Type[Interoperable]] = get_all_interoperability_classes() + + def __init__(self) -> None: + pass + + def convert_tool(self, *, tool: Any, type: str) -> Tool: + interop_cls = self.get_interoperability_class(type) + interop = interop_cls() + return interop.convert_tool(tool) + + @classmethod + def get_interoperability_class(cls, type: str) -> Type[Interoperable]: + if type not in cls._interoperability_classes: + raise ValueError(f"Interoperability class {type} not found") + return cls._interoperability_classes[type] + + @classmethod + def supported_types(cls) -> List[str]: + return sorted(cls._interoperability_classes.keys()) + @classmethod + def register_interoperability_class(cls, name: str, interoperability_class: Type[Interoperable]) -> None: + if not issubclass(interoperability_class, Interoperable): + raise ValueError( + f"Expected a class implementing `Interoperable` protocol, got {type(interoperability_class)}" + ) -@runtime_checkable -class Interoperable(Protocol): - def convert_tool(self, tool: Any) -> Tool: ... + cls._interoperability_classes[name] = interoperability_class diff --git a/autogen/interop/interoperable.py b/autogen/interop/interoperable.py new file mode 100644 index 0000000000..dfe0f82500 --- /dev/null +++ b/autogen/interop/interoperable.py @@ -0,0 +1,14 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +from typing import Any, Protocol, runtime_checkable + +from ..tools import Tool + +__all__ = ["Interoperable"] + + +@runtime_checkable +class Interoperable(Protocol): + def convert_tool(self, tool: Any) -> Tool: ... diff --git a/autogen/interop/langchain/langchain.py b/autogen/interop/langchain/langchain.py index ad5c2a12a2..b3f4713c63 100644 --- a/autogen/interop/langchain/langchain.py +++ b/autogen/interop/langchain/langchain.py @@ -7,7 +7,7 @@ from langchain_core.tools import BaseTool as LangchainTool from ...tools import Tool -from ..interoperability import Interoperable +from ..interoperable import Interoperable __all__ = ["LangchainInteroperability"] diff --git a/test/interop/test_helpers.py b/test/interop/test_helpers.py new file mode 100644 index 0000000000..9355fa510d --- /dev/null +++ b/test/interop/test_helpers.py @@ -0,0 +1,62 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +import sys + +import pytest + +from autogen.interop import Interoperability, Interoperable +from autogen.interop.helpers import ( + find_classes_implementing_protocol, + get_all_interoperability_classes, + import_submodules, +) + + +class TestHelpers: + @pytest.fixture(autouse=True) + def setup_method(self) -> None: + self.imported_modules = import_submodules("autogen.interop") + + def test_import_submodules(self) -> None: + assert "autogen.interop.helpers" in self.imported_modules + + def test_find_classes_implementing_protocol(self) -> None: + actual = find_classes_implementing_protocol(self.imported_modules, Interoperable) + print(f"test_find_classes_implementing_protocol: {actual=}") + + assert Interoperability in actual + expected_count = 1 + + if sys.version_info >= (3, 10) and sys.version_info < (3, 13): + from autogen.interop.crewai import CrewAIInteroperability + + assert CrewAIInteroperability in actual + expected_count += 1 + + if sys.version_info >= (3, 10): + from autogen.interop.langchain import LangchainInteroperability + + assert LangchainInteroperability in actual + expected_count += 1 + + assert len(actual) == expected_count + + def test_get_all_interoperability_classes(self) -> None: + + actual = get_all_interoperability_classes() + + if sys.version_info < (3, 10): + assert actual == {} + + if sys.version_info >= (3, 10) and sys.version_info < (3, 13): + from autogen.interop.crewai import CrewAIInteroperability + from autogen.interop.langchain import LangchainInteroperability + + assert actual == {"crewai": CrewAIInteroperability, "langchain": LangchainInteroperability} + + if sys.version_info >= (3, 13): + from autogen.interop.langchain import LangchainInteroperability + + assert actual == {"langchain": LangchainInteroperability} diff --git a/test/interop/test_interoperability.py b/test/interop/test_interoperability.py index 164854f6aa..e0f5d3f70a 100644 --- a/test/interop/test_interoperability.py +++ b/test/interop/test_interoperability.py @@ -2,8 +2,80 @@ # # SPDX-License-Identifier: Apache-2.0 -from autogen.interop import Interoperable +import sys +from tempfile import TemporaryDirectory +from typing import Any +import pytest -def test_interoperable() -> None: - assert Interoperable is not None +from autogen.interop import Interoperability, Interoperable +from autogen.tools.tool import Tool + + +class TestInteroperability: + def test_supported_types(self) -> None: + actual = Interoperability.supported_types() + + if sys.version_info < (3, 10): + assert actual == [] + + if sys.version_info >= (3, 10) and sys.version_info < (3, 13): + assert actual == ["crewai", "langchain"] + + if sys.version_info >= (3, 13): + assert actual == ["langchain"] + + def test_register_interoperability_class(self) -> None: + org_interoperability_classes = Interoperability._interoperability_classes + try: + + class MyInteroperability: + def convert_tool(self, tool: Any) -> Tool: + return Tool(name="test", description="test description", func=tool) + + Interoperability.register_interoperability_class("my_interop", MyInteroperability) + assert Interoperability.get_interoperability_class("my_interop") == MyInteroperability + + interop = Interoperability() + tool = interop.convert_tool(type="my_interop", tool=lambda x: x) + assert tool.name == "test" + assert tool.description == "test description" + assert tool.func("hello") == "hello" + + finally: + Interoperability._interoperability_classes = org_interoperability_classes + + @pytest.mark.skipif( + sys.version_info < (3, 10) or sys.version_info >= (3, 13), reason="Only Python 3.10, 3.11, 3.12 are supported" + ) + def test_crewai(self) -> None: + from crewai_tools import FileReadTool + + crewai_tool = FileReadTool() + + interoperability = Interoperability() + tool = interoperability.convert_tool(type="crewai", tool=crewai_tool) + + with TemporaryDirectory() as tmp_dir: + file_path = f"{tmp_dir}/test.txt" + with open(file_path, "w") as file: + file.write("Hello, World!") + + assert tool.name == "Read_a_file_s_content" + assert ( + tool.description + == "A tool that can be used to read a file's content. (IMPORTANT: When using arguments, put them all in an `args` dictionary)" + ) + + model_type = crewai_tool.args_schema + + args = model_type(file_path=file_path) + + assert tool.func(args=args) == "Hello, World!" + + @pytest.mark.skipif( + sys.version_info < (3, 9), reason="Only Python 3.9 and above are supported for LangchainInteroperability" + ) + @pytest.mark.skip(reason="This test is not yet implemented") + def test_langchain(self) -> None: + raise NotImplementedError("This test is not yet implemented") diff --git a/test/interop/test_interoperable.py b/test/interop/test_interoperable.py new file mode 100644 index 0000000000..164854f6aa --- /dev/null +++ b/test/interop/test_interoperable.py @@ -0,0 +1,9 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +from autogen.interop import Interoperable + + +def test_interoperable() -> None: + assert Interoperable is not None From fd2b089264b110b390dba5e0fb8563af53c4b5f7 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Wed, 18 Dec 2024 13:09:05 +0100 Subject: [PATCH 40/70] fixes Signed-off-by: Davor Runje --- test/interop/crewai/test_crewai.py | 6 +++--- test/interop/test_helpers.py | 6 +++--- test/interop/test_interoperability.py | 5 ++++- 3 files changed, 10 insertions(+), 7 deletions(-) diff --git a/test/interop/crewai/test_crewai.py b/test/interop/crewai/test_crewai.py index 1f0bae4bb1..1a2cbbd513 100644 --- a/test/interop/crewai/test_crewai.py +++ b/test/interop/crewai/test_crewai.py @@ -4,8 +4,8 @@ import os import sys -import unittest from tempfile import TemporaryDirectory +from unittest.mock import MagicMock import pytest from conftest import reason, skip_openai @@ -13,7 +13,7 @@ if sys.version_info >= (3, 10) and sys.version_info < (3, 13): from crewai_tools import FileReadTool else: - FileReadTool = unittest.mock.MagicMock() + FileReadTool = MagicMock() from autogen import AssistantAgent, UserProxyAgent from autogen.interop import Interoperable @@ -21,7 +21,7 @@ if sys.version_info >= (3, 10) and sys.version_info < (3, 13): from autogen.interop.crewai import CrewAIInteroperability else: - CrewAIInteroperability = unittest.mock.MagicMock() + CrewAIInteroperability = MagicMock() # skip if python version is not in [3.10, 3.11, 3.12] diff --git a/test/interop/test_helpers.py b/test/interop/test_helpers.py index 9355fa510d..f3a5ad09ef 100644 --- a/test/interop/test_helpers.py +++ b/test/interop/test_helpers.py @@ -35,7 +35,7 @@ def test_find_classes_implementing_protocol(self) -> None: assert CrewAIInteroperability in actual expected_count += 1 - if sys.version_info >= (3, 10): + if sys.version_info >= (3, 9): from autogen.interop.langchain import LangchainInteroperability assert LangchainInteroperability in actual @@ -47,7 +47,7 @@ def test_get_all_interoperability_classes(self) -> None: actual = get_all_interoperability_classes() - if sys.version_info < (3, 10): + if sys.version_info < (3, 9): assert actual == {} if sys.version_info >= (3, 10) and sys.version_info < (3, 13): @@ -56,7 +56,7 @@ def test_get_all_interoperability_classes(self) -> None: assert actual == {"crewai": CrewAIInteroperability, "langchain": LangchainInteroperability} - if sys.version_info >= (3, 13): + if (sys.version_info >= (3, 9) and sys.version_info < (3, 10)) and sys.version_info >= (3, 13): from autogen.interop.langchain import LangchainInteroperability assert actual == {"langchain": LangchainInteroperability} diff --git a/test/interop/test_interoperability.py b/test/interop/test_interoperability.py index e0f5d3f70a..dacdc16c87 100644 --- a/test/interop/test_interoperability.py +++ b/test/interop/test_interoperability.py @@ -16,9 +16,12 @@ class TestInteroperability: def test_supported_types(self) -> None: actual = Interoperability.supported_types() - if sys.version_info < (3, 10): + if sys.version_info < (3, 9): assert actual == [] + if sys.version_info >= (3, 9) and sys.version_info < (3, 10): + assert actual == ["langchain"] + if sys.version_info >= (3, 10) and sys.version_info < (3, 13): assert actual == ["crewai", "langchain"] From 79ea2538508133df0fa1bc0003526fff86af5848 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Wed, 18 Dec 2024 14:54:48 +0100 Subject: [PATCH 41/70] Add pydantic_retries.ipynb for pydantic debugging --- notebook/pydantic_retries.ipynb | 101 ++++++++++++++++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 notebook/pydantic_retries.ipynb diff --git a/notebook/pydantic_retries.ipynb b/notebook/pydantic_retries.ipynb new file mode 100644 index 0000000000..150c7c0eae --- /dev/null +++ b/notebook/pydantic_retries.ipynb @@ -0,0 +1,101 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from pydantic_ai import RunContext, Tool, ModelRetry\n", + "import nest_asyncio" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "nest_asyncio.apply()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pydantic_ai import Agent\n", + "\n", + "\n", + "def get_player_name(ctx: RunContext[str]) -> str:\n", + " \"\"\"Get the player's name.\"\"\"\n", + " # raise ValueError('Could not find player')\n", + " assert ctx.retry == 0\n", + " raise ModelRetry('Could not find player')\n", + "\n", + "agent = Agent(\n", + " \"openai:gpt-4o\",\n", + " deps_type=str,\n", + " tools=[get_player_name],\n", + " retries=1,\n", + ")\n", + "result1 = agent.run_sync(\"Get players name\", deps=\"Anne\")\n", + "for message in result1.all_messages():\n", + " print(message)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "result2 = agent.run_sync(\"Get players name\", deps=\"Anne\", message_history=result1.all_messages())\n", + "for message in result2.all_messages():\n", + " print(message)\n", + "\n", + "print(agent._current_result_retry)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "result = agent.run_sync(\"Get players name\", deps=\"Anne\", message_history=result2.all_messages())\n", + "for message in result.all_messages():\n", + " print(message)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 89e1ac9d0e76da88909bd212d6fbce815464c20b Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Wed, 18 Dec 2024 15:11:06 +0100 Subject: [PATCH 42/70] Initial pydantic ai tools notebook tutorial added --- notebook/pydantic_retries.ipynb | 7 +- notebook/tools_crewai_tools_integration.ipynb | 6 +- .../tools_langchain_tools_integration.ipynb | 2 +- .../tools_pydantic_ai_tools_integration.ipynb | 146 ++++++++++++++++++ 4 files changed, 154 insertions(+), 7 deletions(-) create mode 100644 notebook/tools_pydantic_ai_tools_integration.ipynb diff --git a/notebook/pydantic_retries.ipynb b/notebook/pydantic_retries.ipynb index 150c7c0eae..c5efadfd10 100644 --- a/notebook/pydantic_retries.ipynb +++ b/notebook/pydantic_retries.ipynb @@ -6,8 +6,8 @@ "metadata": {}, "outputs": [], "source": [ - "from pydantic_ai import RunContext, Tool, ModelRetry\n", - "import nest_asyncio" + "import nest_asyncio\n", + "from pydantic_ai import ModelRetry, RunContext, Tool" ] }, { @@ -32,7 +32,8 @@ " \"\"\"Get the player's name.\"\"\"\n", " # raise ValueError('Could not find player')\n", " assert ctx.retry == 0\n", - " raise ModelRetry('Could not find player')\n", + " raise ModelRetry(\"Could not find player\")\n", + "\n", "\n", "agent = Agent(\n", " \"openai:gpt-4o\",\n", diff --git a/notebook/tools_crewai_tools_integration.ipynb b/notebook/tools_crewai_tools_integration.ipynb index f32d2c2591..07bdd0e341 100644 --- a/notebook/tools_crewai_tools_integration.ipynb +++ b/notebook/tools_crewai_tools_integration.ipynb @@ -50,7 +50,7 @@ "from crewai_tools import FileWriterTool, ScrapeWebsiteTool\n", "\n", "from autogen import AssistantAgent, UserProxyAgent\n", - "from autogen.interoperability.crewai import CrewAIInteroperability" + "from autogen.interop.crewai import CrewAIInteroperability" ] }, { @@ -168,7 +168,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -182,7 +182,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.10.16" } }, "nbformat": 4, diff --git a/notebook/tools_langchain_tools_integration.ipynb b/notebook/tools_langchain_tools_integration.ipynb index 8610d2d00e..48a1d0986a 100644 --- a/notebook/tools_langchain_tools_integration.ipynb +++ b/notebook/tools_langchain_tools_integration.ipynb @@ -52,7 +52,7 @@ "from langchain_community.utilities import WikipediaAPIWrapper\n", "\n", "from autogen import AssistantAgent, UserProxyAgent\n", - "from autogen.interoperability.langchain import LangchainInteroperability" + "from autogen.interop.langchain import LangchainInteroperability" ] }, { diff --git a/notebook/tools_pydantic_ai_tools_integration.ipynb b/notebook/tools_pydantic_ai_tools_integration.ipynb new file mode 100644 index 0000000000..1b44cfe53e --- /dev/null +++ b/notebook/tools_pydantic_ai_tools_integration.ipynb @@ -0,0 +1,146 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Integrating PydanticAI Tools with the AG2 Framework\n", + "\n", + "In this tutorial, we demonstrate how to integrate [PydanticAI Tools](https://ai.pydantic.dev/tools/) into the AG2 framework. This process enables smooth interoperability between the two systems, allowing developers to leverage PydanticAI's powerful tools within AG2's flexible agent-based architecture. By the end of this guide, you will understand how to configure agents, convert PydanticAI tools for use in AG2, and validate the integration with a practical example.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Installation\n", + "To integrate LangChain tools into the AG2 framework, install the required dependencies:\n", + "\n", + "```bash\n", + "pip install ag2[interop-pydantic-ai]\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from typing import Optional\n", + "\n", + "from pydantic import BaseModel\n", + "from pydantic_ai import RunContext\n", + "from pydantic_ai.tools import Tool as PydanticAITool\n", + "\n", + "from autogen import AssistantAgent, UserProxyAgent\n", + "from autogen.interop.pydantic_ai import PydanticAIInteroperability" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Agent Configuration\n", + "\n", + "Configure the agents for the interaction.\n", + "- `config_list` defines the LLM configurations, including the model and API key.\n", + "- `UserProxyAgent` simulates user inputs without requiring actual human interaction (set to `NEVER`).\n", + "- `AssistantAgent` represents the AI agent, configured with the LLM settings." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "config_list = [{\"model\": \"gpt-4o\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", + "user_proxy = UserProxyAgent(\n", + " name=\"User\",\n", + " human_input_mode=\"NEVER\",\n", + ")\n", + "\n", + "chatbot = AssistantAgent(\n", + " name=\"chatbot\",\n", + " llm_config={\"config_list\": config_list},\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class Player(BaseModel):\n", + " name: str\n", + " age: int\n", + "\n", + "\n", + "def get_player(ctx: RunContext[Player], additional_info: Optional[str] = None) -> str: # type: ignore[valid-type]\n", + " \"\"\"Get the player's name.\n", + "\n", + " Args:\n", + " additional_info: Additional information which can be used.\n", + " \"\"\"\n", + " return f\"Name: {ctx.deps.name}, Age: {ctx.deps.age}, Additional info: {additional_info}\" # type: ignore[attr-defined]\n", + "\n", + "\n", + "pydantic_ai_interop = PydanticAIInteroperability()\n", + "pydantic_ai_tool = PydanticAITool(get_player, takes_ctx=True)\n", + "\n", + "player = Player(name=\"Luka\", age=25)\n", + "ag2_tool = pydantic_ai_interop.convert_tool(tool=pydantic_ai_tool, deps=player)\n", + "\n", + "ag2_tool.register_for_execution(user_proxy)\n", + "ag2_tool.register_for_llm(chatbot)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "user_proxy.initiate_chat(\n", + " recipient=chatbot, message=\"Get player, for additional information use 'goal keeper'\", max_turns=3\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From d0eab731aa896c64eb6994c9846b66ccf4ece6e6 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Wed, 18 Dec 2024 15:37:55 +0100 Subject: [PATCH 43/70] Add tools_pydantic_ai_tools_integration.ipynb tutorial notebook --- .../tools_pydantic_ai_tools_integration.ipynb | 39 ++++++++++++++++++- 1 file changed, 38 insertions(+), 1 deletion(-) diff --git a/notebook/tools_pydantic_ai_tools_integration.ipynb b/notebook/tools_pydantic_ai_tools_integration.ipynb index 1b44cfe53e..edf2170135 100644 --- a/notebook/tools_pydantic_ai_tools_integration.ipynb +++ b/notebook/tools_pydantic_ai_tools_integration.ipynb @@ -24,7 +24,16 @@ { "cell_type": "markdown", "metadata": {}, - "source": [] + "source": [ + "## Imports\n", + "\n", + "Import necessary modules and tools.\n", + "- `BaseModel`: Used to define data structures for tool inputs and outputs.\n", + "- `RunContext`: Provides context during the execution of tools.\n", + "- `PydanticAITool`: Represents a tool in the PydanticAI framework.\n", + "- `AssistantAgent` and `UserProxyAgent`: Agents that facilitate communication in the AG2 framework.\n", + "- `PydanticAIInteroperability`: A bridge for integrating PydanticAI tools with the AG2 framework." + ] }, { "cell_type": "code", @@ -73,6 +82,22 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tool Integration\n", + "\n", + "Integrate the PydanticAI tool with AG2.\n", + "\n", + "- Define a `Player` model using `BaseModel` to structure the input data.\n", + "- Use `RunContext` to securely inject dependencies (like the `Player` instance) into the tool function without exposing them to the LLM.\n", + "- Implement `get_player` to define the tool's functionality, accessing `ctx.deps` for injected data.\n", + "- Convert the tool to an AG2-compatible format with `PydanticAIInteroperability` and register it for execution and LLM communication.\n", + "- Convert the PydanticAI tool into an AG2-compatible format using `convert_tool`.\n", + "- Register the tool for both execution and communication with the LLM by associating it with the `user_proxy` and `chatbot`." + ] + }, { "cell_type": "code", "execution_count": 3, @@ -96,6 +121,7 @@ "pydantic_ai_interop = PydanticAIInteroperability()\n", "pydantic_ai_tool = PydanticAITool(get_player, takes_ctx=True)\n", "\n", + "# player will be injected as a dependency\n", "player = Player(name=\"Luka\", age=25)\n", "ag2_tool = pydantic_ai_interop.convert_tool(tool=pydantic_ai_tool, deps=player)\n", "\n", @@ -103,6 +129,17 @@ "ag2_tool.register_for_llm(chatbot)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initiate a conversation between the `UserProxyAgent` and the `AssistantAgent`.\n", + "\n", + "- Use the `initiate_chat` method to send a message from the `user_proxy` to the `chatbot`.\n", + "- In this example, the user requests the chatbot to retrieve player information, providing \"goal keeper\" as additional context.\n", + "- The `Player` instance is securely injected into the tool using `RunContext`, ensuring the chatbot can retrieve and use this data during the interaction." + ] + }, { "cell_type": "code", "execution_count": null, From 64f0d28906ccff4330c267d43914a2ce514620c1 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Wed, 18 Dec 2024 15:53:46 +0100 Subject: [PATCH 44/70] Delete testing notebooks and fix type checks --- autogen/interop/interoperability.py | 1 + notebook/pydantic_ai.ipynb | 473 ---------------------------- notebook/pydantic_retries.ipynb | 102 ------ 3 files changed, 1 insertion(+), 575 deletions(-) delete mode 100644 notebook/pydantic_ai.ipynb delete mode 100644 notebook/pydantic_retries.ipynb diff --git a/autogen/interop/interoperability.py b/autogen/interop/interoperability.py index 436e75bb43..1e3c786f36 100644 --- a/autogen/interop/interoperability.py +++ b/autogen/interop/interoperability.py @@ -6,6 +6,7 @@ from ..tools import Tool +__all__ = ["Interoperable"] @runtime_checkable class Interoperable(Protocol): diff --git a/notebook/pydantic_ai.ipynb b/notebook/pydantic_ai.ipynb deleted file mode 100644 index 5451c33126..0000000000 --- a/notebook/pydantic_ai.ipynb +++ /dev/null @@ -1,473 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# ! pip install pydantic-ai" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Tools WITHOUT Context " - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import random\n", - "\n", - "from pydantic_ai import RunContext, Tool\n", - "\n", - "\n", - "def roll_dice(name: str = \"Rolling dice\") -> str:\n", - " \"\"\"Roll a six-sided dice and return the result.\"\"\"\n", - " return str(random.randint(1, 6))\n", - "\n", - "\n", - "rool_dice_tool = Tool(roll_dice)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "rool_dice_tool.function()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(rool_dice_tool.name)\n", - "print(rool_dice_tool.description)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "rool_dice_tool._parameters_json_schema" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import Optional\n", - "\n", - "\n", - "def foobar(a: int, b: str, c: Optional[dict[str, list[float]]] = None) -> str:\n", - " \"\"\"Get me foobar.\n", - "\n", - " Args:\n", - " a: apple pie\n", - " b: banana cake\n", - " c: carrot smoothie\n", - " \"\"\"\n", - " return f\"{a} {b} {c}\"\n", - "\n", - "\n", - "foobar_tool = Tool(foobar)\n", - "\n", - "print(foobar_tool.name)\n", - "print(foobar_tool.description)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "foobar_tool._parameters_json_schema" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Tools WITH Context (simple string)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "def get_player_name(ctx: RunContext[str]) -> str:\n", - " \"\"\"Get the player's name.\"\"\"\n", - " return ctx.deps\n", - "\n", - "\n", - "get_player_name_tool = Tool(get_player_name, takes_ctx=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "# ! pip install nest_asyncio" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "import nest_asyncio\n", - "\n", - "nest_asyncio.apply()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "from pydantic_ai import Agent\n", - "\n", - "agent_a = Agent(\n", - " \"openai:gpt-4o\",\n", - " deps_type=str,\n", - " tools=[get_player_name_tool],\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "result = agent_a.run_sync(\"Get players name\", deps=\"Anne\")\n", - "result" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "result.all_messages()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Tools WITH Context (pydantic)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "from pydantic import BaseModel\n", - "\n", - "\n", - "class Player(BaseModel):\n", - " name: str\n", - " age: int\n", - "\n", - "\n", - "def get_player(ctx: RunContext[Player], additional_info: Optional[str] = None) -> str:\n", - " \"\"\"Get the player's name.\n", - "\n", - " Args:\n", - " additional_info: Additional information which can be used.\n", - " \"\"\"\n", - " return f\"Name: {ctx.deps.name}, Age: {ctx.deps.age}, Additional info: {additional_info}\"\n", - "\n", - "\n", - "get_player_tool = Tool(get_player, takes_ctx=True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(get_player_tool.name)\n", - "print(get_player_tool.description)\n", - "print(get_player_tool._parameters_json_schema)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "agent_b = Agent(\n", - " \"openai:gpt-4o\",\n", - " deps_type=Player,\n", - " tools=[get_player_tool],\n", - ")\n", - "\n", - "player = Player(name=\"Luka\", age=25)\n", - "result_b = agent_b.run_sync(\"Get player\", deps=player)\n", - "result_b.all_messages()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Dependency injection" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "# Initial Source: https://github.com/airtai/fastagency/blob/main/fastagency/api/dependency_injection.py\n", - "\n", - "from functools import wraps\n", - "from inspect import signature\n", - "from typing import Any, Callable\n", - "\n", - "\n", - "def inject_params(f: Callable[..., Any], ctx: Any) -> Callable[..., Any]:\n", - "\n", - " @wraps(f)\n", - " def wrapper(*args: Any, **kwargs: Any) -> Any:\n", - " kwargs.pop(\"ctx\", None)\n", - " return f(**kwargs, ctx=ctx)\n", - "\n", - " sig = signature(f)\n", - " new_params = [param for name, param in sig.parameters.items() if name != \"ctx\"]\n", - "\n", - " wrapper.__signature__ = sig.replace(parameters=new_params) # type: ignore[attr-defined]\n", - "\n", - " return wrapper" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "ctx = RunContext(\n", - " deps=Player(name=\"Luka\", age=25),\n", - " retry=get_player_tool.max_retries, # Not sure\n", - " messages=[], # Not sure\n", - " tool_name=get_player_tool.name,\n", - ")\n", - "f_injected = inject_params(f=get_player_tool.function, ctx=ctx)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "f_injected.__signature__" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "f_injected(additional_info=\"Hello\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## AG2 Integration" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "\n", - "from autogen import AssistantAgent, UserProxyAgent" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "config_list = [{\"model\": \"gpt-4o\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", - "user_proxy = UserProxyAgent(\n", - " name=\"User\",\n", - " human_input_mode=\"NEVER\",\n", - ")\n", - "\n", - "chatbot = AssistantAgent(\n", - " name=\"chatbot\",\n", - " llm_config={\"config_list\": config_list},\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import Dict\n", - "\n", - "\n", - "def create_function_schema(name: str, description: str, parameters: Dict[str, Any]) -> Dict[str, Any]:\n", - " # parameters are:\n", - " # {'properties': {'additional_info': {'anyOf': [{'type': 'string'},\n", - " # {'type': 'null'}],\n", - " # 'description': 'Additional information which can be used.',\n", - " # 'title': 'Additional Info'}},\n", - " # 'required': ['additional_info'],\n", - " # 'type': 'object',\n", - " # 'additionalProperties': False}\n", - "\n", - " # response should be:\n", - " # {'type': 'function', 'function': {'description': \"Get the player's name.\", 'name': 'get_player', 'parameters': {'type': 'object', 'properties': {'additional_info': {'anyOf': [{'type': 'string'}, {'type': 'null'}], 'default': None, 'description': 'additional_info'}}, 'required': []}}\n", - " return {\n", - " \"type\": \"function\",\n", - " \"function\": {\n", - " \"name\": name,\n", - " \"description\": description,\n", - " \"parameters\": parameters,\n", - " },\n", - " }" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "get_player_tool._parameters_json_schema" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "function_schema = create_function_schema(\n", - " name=get_player_tool.name,\n", - " description=get_player_tool.description,\n", - " parameters=get_player_tool._parameters_json_schema,\n", - ")\n", - "function_schema" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [], - "source": [ - "tool = get_player_tool\n", - "\n", - "f_injected_ctx = inject_params(f=tool.function, ctx=ctx)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "user_proxy.register_for_execution(name=tool.name)(f_injected_ctx)\n", - "# chatbot.register_for_llm(description=tool.description, name=tool.name)(f_injected_ctx)\n", - "chatbot.update_tool_signature(function_schema, is_remove=False)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "chatbot.llm_config[\"tools\"]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "user_proxy.initiate_chat(\n", - " recipient=chatbot, message=\"Get player, for additional information use 'goal keeper'\", max_turns=3\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebook/pydantic_retries.ipynb b/notebook/pydantic_retries.ipynb deleted file mode 100644 index c5efadfd10..0000000000 --- a/notebook/pydantic_retries.ipynb +++ /dev/null @@ -1,102 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import nest_asyncio\n", - "from pydantic_ai import ModelRetry, RunContext, Tool" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "nest_asyncio.apply()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from pydantic_ai import Agent\n", - "\n", - "\n", - "def get_player_name(ctx: RunContext[str]) -> str:\n", - " \"\"\"Get the player's name.\"\"\"\n", - " # raise ValueError('Could not find player')\n", - " assert ctx.retry == 0\n", - " raise ModelRetry(\"Could not find player\")\n", - "\n", - "\n", - "agent = Agent(\n", - " \"openai:gpt-4o\",\n", - " deps_type=str,\n", - " tools=[get_player_name],\n", - " retries=1,\n", - ")\n", - "result1 = agent.run_sync(\"Get players name\", deps=\"Anne\")\n", - "for message in result1.all_messages():\n", - " print(message)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "result2 = agent.run_sync(\"Get players name\", deps=\"Anne\", message_history=result1.all_messages())\n", - "for message in result2.all_messages():\n", - " print(message)\n", - "\n", - "print(agent._current_result_retry)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "result = agent.run_sync(\"Get players name\", deps=\"Anne\", message_history=result2.all_messages())\n", - "for message in result.all_messages():\n", - " print(message)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 13cdc359274162be9d969ff5b1f6dd44ea99e406 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Wed, 18 Dec 2024 15:57:53 +0100 Subject: [PATCH 45/70] Fix pre-commit --- autogen/interop/interoperability.py | 1 + 1 file changed, 1 insertion(+) diff --git a/autogen/interop/interoperability.py b/autogen/interop/interoperability.py index 1ae0a528ed..2c9ed1ffbf 100644 --- a/autogen/interop/interoperability.py +++ b/autogen/interop/interoperability.py @@ -9,6 +9,7 @@ __all__ = ["Interoperable"] + class Interoperability: _interoperability_classes: Dict[str, Type[Interoperable]] = get_all_interoperability_classes() From 7261503d7634b10f51d4a6beaefef4b27a9f8406 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Wed, 18 Dec 2024 16:25:33 +0100 Subject: [PATCH 46/70] Fix tests --- test/interop/pydantic_ai/test_pydantic_ai.py | 2 +- test/interop/test_helpers.py | 11 +++++++++-- test/interop/test_interoperability.py | 6 +++--- 3 files changed, 13 insertions(+), 6 deletions(-) diff --git a/test/interop/pydantic_ai/test_pydantic_ai.py b/test/interop/pydantic_ai/test_pydantic_ai.py index 4bf3304366..3e29ceec57 100644 --- a/test/interop/pydantic_ai/test_pydantic_ai.py +++ b/test/interop/pydantic_ai/test_pydantic_ai.py @@ -162,7 +162,7 @@ def get_player(ctx: RunContext[Player], additional_info: Optional[str] = None) - self.tool = self.pydantic_ai_interop.convert_tool(tool=pydantic_ai_tool, deps=player) def test_expected_tools(self) -> None: - config_list = [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}] + config_list = [{"model": "gpt-4o", "api_key": "abc"}] chatbot = AssistantAgent( name="chatbot", llm_config={"config_list": config_list}, diff --git a/test/interop/test_helpers.py b/test/interop/test_helpers.py index f3a5ad09ef..76f52a85f4 100644 --- a/test/interop/test_helpers.py +++ b/test/interop/test_helpers.py @@ -37,9 +37,11 @@ def test_find_classes_implementing_protocol(self) -> None: if sys.version_info >= (3, 9): from autogen.interop.langchain import LangchainInteroperability + from autogen.interop.pydantic_ai import PydanticAIInteroperability assert LangchainInteroperability in actual - expected_count += 1 + assert PydanticAIInteroperability in actual + expected_count += 2 assert len(actual) == expected_count @@ -53,8 +55,13 @@ def test_get_all_interoperability_classes(self) -> None: if sys.version_info >= (3, 10) and sys.version_info < (3, 13): from autogen.interop.crewai import CrewAIInteroperability from autogen.interop.langchain import LangchainInteroperability + from autogen.interop.pydantic_ai import PydanticAIInteroperability - assert actual == {"crewai": CrewAIInteroperability, "langchain": LangchainInteroperability} + assert actual == { + "pydanticai": PydanticAIInteroperability, + "crewai": CrewAIInteroperability, + "langchain": LangchainInteroperability, + } if (sys.version_info >= (3, 9) and sys.version_info < (3, 10)) and sys.version_info >= (3, 13): from autogen.interop.langchain import LangchainInteroperability diff --git a/test/interop/test_interoperability.py b/test/interop/test_interoperability.py index dacdc16c87..8dba1c763c 100644 --- a/test/interop/test_interoperability.py +++ b/test/interop/test_interoperability.py @@ -20,13 +20,13 @@ def test_supported_types(self) -> None: assert actual == [] if sys.version_info >= (3, 9) and sys.version_info < (3, 10): - assert actual == ["langchain"] + assert actual == ["langchain", "pydanticai"] if sys.version_info >= (3, 10) and sys.version_info < (3, 13): - assert actual == ["crewai", "langchain"] + assert actual == ["crewai", "langchain", "pydanticai"] if sys.version_info >= (3, 13): - assert actual == ["langchain"] + assert actual == ["langchain", "pydanticai"] def test_register_interoperability_class(self) -> None: org_interoperability_classes = Interoperability._interoperability_classes From 00ecd98741047e896241ebc7670ef2ee4d1aae55 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Wed, 18 Dec 2024 16:33:00 +0100 Subject: [PATCH 47/70] Fix tests --- test/interop/pydantic_ai/test_pydantic_ai.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/test/interop/pydantic_ai/test_pydantic_ai.py b/test/interop/pydantic_ai/test_pydantic_ai.py index 3e29ceec57..8ae3eb6b4c 100644 --- a/test/interop/pydantic_ai/test_pydantic_ai.py +++ b/test/interop/pydantic_ai/test_pydantic_ai.py @@ -82,6 +82,9 @@ def test_with_llm(self) -> None: assert False, "No tool response found in chat messages" +@pytest.mark.skipif( + sys.version_info < (3, 9), reason="Only Python 3.9 and above are supported for LangchainInteroperability" +) class TestPydanticAIInteroperabilityDependencyInjection: def test_dependency_injection(self) -> None: From b4e991fbb8d73937b001d31796e9f46f8fe254fc Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Wed, 18 Dec 2024 16:41:47 +0100 Subject: [PATCH 48/70] Fix tests --- test/interop/pydantic_ai/test_pydantic_ai.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/test/interop/pydantic_ai/test_pydantic_ai.py b/test/interop/pydantic_ai/test_pydantic_ai.py index 8ae3eb6b4c..fc7b7b463f 100644 --- a/test/interop/pydantic_ai/test_pydantic_ai.py +++ b/test/interop/pydantic_ai/test_pydantic_ai.py @@ -144,6 +144,9 @@ def f( assert pydantic_ai_tool.current_retry == 3 +@pytest.mark.skipif( + sys.version_info < (3, 9), reason="Only Python 3.9 and above are supported for LangchainInteroperability" +) class TestPydanticAIInteroperabilityWithContext: @pytest.fixture(autouse=True) def setup(self) -> None: From 1cbbb8b655131e6adf1a218b73cb69d4d260dde5 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Thu, 19 Dec 2024 09:54:13 +0100 Subject: [PATCH 49/70] Add kwargs to convert_tool function --- autogen/interop/crewai/crewai.py | 4 +++- autogen/interop/interoperability.py | 4 ++-- autogen/interop/interoperable.py | 2 +- autogen/interop/langchain/langchain.py | 4 +++- autogen/interop/pydantic_ai/pydantic_ai.py | 2 +- test/interop/test_interoperability.py | 2 +- 6 files changed, 11 insertions(+), 7 deletions(-) diff --git a/autogen/interop/crewai/crewai.py b/autogen/interop/crewai/crewai.py index c391b22888..240ec47960 100644 --- a/autogen/interop/crewai/crewai.py +++ b/autogen/interop/crewai/crewai.py @@ -18,9 +18,11 @@ def _sanitize_name(s: str) -> str: class CrewAIInteroperability(Interoperable): - def convert_tool(self, tool: Any) -> Tool: + def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: if not isinstance(tool, CrewAITool): raise ValueError(f"Expected an instance of `crewai.tools.BaseTool`, got {type(tool)}") + if kwargs: + raise ValueError(f"The CrewAIInteroperability does not support any additional arguments, got {kwargs}") # needed for type checking crewai_tool: CrewAITool = tool # type: ignore[no-any-unimported] diff --git a/autogen/interop/interoperability.py b/autogen/interop/interoperability.py index 2c9ed1ffbf..68190fbf04 100644 --- a/autogen/interop/interoperability.py +++ b/autogen/interop/interoperability.py @@ -16,10 +16,10 @@ class Interoperability: def __init__(self) -> None: pass - def convert_tool(self, *, tool: Any, type: str) -> Tool: + def convert_tool(self, *, tool: Any, type: str, **kwargs: Any) -> Tool: interop_cls = self.get_interoperability_class(type) interop = interop_cls() - return interop.convert_tool(tool) + return interop.convert_tool(tool, **kwargs) @classmethod def get_interoperability_class(cls, type: str) -> Type[Interoperable]: diff --git a/autogen/interop/interoperable.py b/autogen/interop/interoperable.py index dfe0f82500..1b9bed1405 100644 --- a/autogen/interop/interoperable.py +++ b/autogen/interop/interoperable.py @@ -11,4 +11,4 @@ @runtime_checkable class Interoperable(Protocol): - def convert_tool(self, tool: Any) -> Tool: ... + def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: ... diff --git a/autogen/interop/langchain/langchain.py b/autogen/interop/langchain/langchain.py index b3f4713c63..1507796c5d 100644 --- a/autogen/interop/langchain/langchain.py +++ b/autogen/interop/langchain/langchain.py @@ -13,9 +13,11 @@ class LangchainInteroperability(Interoperable): - def convert_tool(self, tool: Any) -> Tool: + def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: if not isinstance(tool, LangchainTool): raise ValueError(f"Expected an instance of `langchain_core.tools.BaseTool`, got {type(tool)}") + if kwargs: + raise ValueError(f"The LangchainInteroperability does not support any additional arguments, got {kwargs}") # needed for type checking langchain_tool: LangchainTool = tool # type: ignore[no-any-unimported] diff --git a/autogen/interop/pydantic_ai/pydantic_ai.py b/autogen/interop/pydantic_ai/pydantic_ai.py index 27a146704c..0d4e464579 100644 --- a/autogen/interop/pydantic_ai/pydantic_ai.py +++ b/autogen/interop/pydantic_ai/pydantic_ai.py @@ -54,7 +54,7 @@ def wrapper(*args: Any, **kwargs: Any) -> Any: return wrapper - def convert_tool(self, tool: Any, deps: Any = None) -> AG2PydanticAITool: + def convert_tool(self, tool: Any, deps: Any = None, **kwargs: Any) -> AG2PydanticAITool: if not isinstance(tool, PydanticAITool): raise ValueError(f"Expected an instance of `pydantic_ai.tools.Tool`, got {type(tool)}") diff --git a/test/interop/test_interoperability.py b/test/interop/test_interoperability.py index 8dba1c763c..df7789dd13 100644 --- a/test/interop/test_interoperability.py +++ b/test/interop/test_interoperability.py @@ -33,7 +33,7 @@ def test_register_interoperability_class(self) -> None: try: class MyInteroperability: - def convert_tool(self, tool: Any) -> Tool: + def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: return Tool(name="test", description="test description", func=tool) Interoperability.register_interoperability_class("my_interop", MyInteroperability) From 5507bf57ac68a35e71ae284aab6df5c22b359816 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Thu, 19 Dec 2024 10:28:21 +0100 Subject: [PATCH 50/70] Raise exception if tool expects context but deps param isn't provided --- autogen/interop/pydantic_ai/pydantic_ai.py | 11 ++++++++++- test/interop/pydantic_ai/test_pydantic_ai.py | 8 ++++++-- 2 files changed, 16 insertions(+), 3 deletions(-) diff --git a/autogen/interop/pydantic_ai/pydantic_ai.py b/autogen/interop/pydantic_ai/pydantic_ai.py index 0d4e464579..fe778ea904 100644 --- a/autogen/interop/pydantic_ai/pydantic_ai.py +++ b/autogen/interop/pydantic_ai/pydantic_ai.py @@ -3,6 +3,7 @@ # SPDX-License-Identifier: Apache-2.0 +import warnings from functools import wraps from inspect import signature from typing import Any, Callable, Optional @@ -61,7 +62,15 @@ def convert_tool(self, tool: Any, deps: Any = None, **kwargs: Any) -> AG2Pydanti # needed for type checking pydantic_ai_tool: PydanticAITool = tool # type: ignore[no-any-unimported] - if deps is not None: + if tool.takes_ctx and deps is None: + raise ValueError("If the tool takes a context, the `deps` argument must be provided") + if not tool.takes_ctx and deps is not None: + warnings.warn( + "The `deps` argument is provided but will be ignored because the tool does not take a context.", + UserWarning, + ) + + if tool.takes_ctx: ctx = RunContext( deps=deps, retry=0, diff --git a/test/interop/pydantic_ai/test_pydantic_ai.py b/test/interop/pydantic_ai/test_pydantic_ai.py index fc7b7b463f..6b5dae9590 100644 --- a/test/interop/pydantic_ai/test_pydantic_ai.py +++ b/test/interop/pydantic_ai/test_pydantic_ai.py @@ -163,9 +163,13 @@ def get_player(ctx: RunContext[Player], additional_info: Optional[str] = None) - return f"Name: {ctx.deps.name}, Age: {ctx.deps.age}, Additional info: {additional_info}" # type: ignore[attr-defined] self.pydantic_ai_interop = PydanticAIInteroperability() - pydantic_ai_tool = PydanticAITool(get_player, takes_ctx=True) + self.pydantic_ai_tool = PydanticAITool(get_player, takes_ctx=True) player = Player(name="Luka", age=25) - self.tool = self.pydantic_ai_interop.convert_tool(tool=pydantic_ai_tool, deps=player) + self.tool = self.pydantic_ai_interop.convert_tool(tool=self.pydantic_ai_tool, deps=player) + + def test_convert_tool_raises_error_if_take_ctx_is_true_and_deps_is_none(self) -> None: + with pytest.raises(ValueError, match="If the tool takes a context, the `deps` argument must be provided"): + self.pydantic_ai_interop.convert_tool(tool=self.pydantic_ai_tool, deps=None) def test_expected_tools(self) -> None: config_list = [{"model": "gpt-4o", "api_key": "abc"}] From c731506a29cef6696ec0fe2e5a212704a2957b78 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Thu, 19 Dec 2024 11:45:06 +0100 Subject: [PATCH 51/70] Add tools_interoperability.ipynb --- notebook/tools_crewai_tools_integration.ipynb | 2 +- notebook/tools_interoperability.ipynb | 418 ++++++++++++++++++ 2 files changed, 419 insertions(+), 1 deletion(-) create mode 100644 notebook/tools_interoperability.ipynb diff --git a/notebook/tools_crewai_tools_integration.ipynb b/notebook/tools_crewai_tools_integration.ipynb index 07bdd0e341..553025a43f 100644 --- a/notebook/tools_crewai_tools_integration.ipynb +++ b/notebook/tools_crewai_tools_integration.ipynb @@ -151,7 +151,7 @@ "ag2_tool.register_for_execution(user_proxy)\n", "ag2_tool.register_for_llm(chatbot)\n", "\n", - "message = \"Scape the website https://ag2.ai/\"\n", + "message = \"Scrape the website https://ag2.ai/\"\n", "\n", "chat_result = user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)" ] diff --git a/notebook/tools_interoperability.ipynb b/notebook/tools_interoperability.ipynb new file mode 100644 index 0000000000..00469be0d4 --- /dev/null +++ b/notebook/tools_interoperability.ipynb @@ -0,0 +1,418 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cross-Framework LLM Tool Integration with AG2\n", + "\n", + "In this tutorial, we demonstrate how to integrate LLM tools from various frameworks—including [LangChain Tools](https://python.langchain.com/v0.1/docs/modules/tools), [CrewAI Tools](https://github.com/crewAIInc/crewAI-tools/tree/main), and [PydanticAI Tools](https://ai.pydantic.dev/tools/) into the AG2 framework. This process enables smooth interoperability between these systems, allowing developers to leverage the unique capabilities of each toolset within AG2's flexible agent-based architecture. By the end of this guide, you will understand how to configure agents, adapt these tools for use in AG2, and validate the integration through practical examples." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## LangChain Tools Integration\n", + "\n", + "LangChain is a popular framework that offers a wide range of tools to work with LLMs. LangChain has already implemented a variety of tools that can be easily integrated into AG2. You can explore the available tools in the [LangChain Community Tools](https://github.com/langchain-ai/langchain/tree/master/libs/community/langchain_community/tools) folder. These tools, such as those for querying APIs, web scraping, and text generation, can be quickly incorporated into AG2, providing powerful functionality for your agents.\n", + "\n", + "### Installation\n", + "To integrate LangChain tools into the AG2 framework, install the required dependencies:\n", + "\n", + "```bash\n", + "pip install ag2[interop-langchain]\n", + "```\n", + "\n", + "Additionally, this notebook uses LangChain's [Wikipedia Tool](https://api.python.langchain.com/en/latest/tools/langchain_community.tools.wikipedia.tool.WikipediaQueryRun.html), which requires the `wikipedia` package. Install it with:\n", + "\n", + "```bash\n", + "pip install wikipedia\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports\n", + "\n", + "Import necessary modules and tools.\n", + "- `WikipediaQueryRun` and `WikipediaAPIWrapper`: Tools for querying Wikipedia.\n", + "- `AssistantAgent` and `UserProxyAgent`: Agents that facilitate communication in the AG2 framework.\n", + "- `Interoperability`: This module acts as a bridge, making it easier to integrate LangChain tools with AG2’s architecture." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "from langchain_community.tools import WikipediaQueryRun\n", + "from langchain_community.utilities import WikipediaAPIWrapper\n", + "\n", + "from autogen import AssistantAgent, UserProxyAgent\n", + "from autogen.interop import Interoperability" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Agent Configuration\n", + "\n", + "Configure the agents for the interaction.\n", + "- `config_list` defines the LLM configurations, including the model and API key.\n", + "- `UserProxyAgent` simulates user inputs without requiring actual human interaction (set to `NEVER`).\n", + "- `AssistantAgent` represents the AI agent, configured with the LLM settings." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "config_list = [{\"model\": \"gpt-4o\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", + "user_proxy = UserProxyAgent(\n", + " name=\"User\",\n", + " human_input_mode=\"NEVER\",\n", + ")\n", + "\n", + "chatbot = AssistantAgent(\n", + " name=\"chatbot\",\n", + " llm_config={\"config_list\": config_list},\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tool Integration\n", + "\n", + "- Initialize and register the LangChain tool with AG2.\n", + "- `WikipediaAPIWrapper`: Configured to fetch the top 1 result from Wikipedia with a maximum of 1000 characters per document.\n", + "- `WikipediaQueryRun`: A LangChain tool that executes Wikipedia queries.\n", + "- `LangchainInteroperability`: Converts the LangChain tool into a format compatible with the AG2 framework.\n", + "- `ag2_tool.register_for_execution(user_proxy)`: Registers the tool for use by the user_proxy agent.\n", + "- `ag2_tool.register_for_llm(chatbot)`: Registers the tool for integration with the chatbot agent.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=1000)\n", + "langchain_tool = WikipediaQueryRun(api_wrapper=api_wrapper)\n", + "\n", + "interop = Interoperability()\n", + "ag2_tool = interop.convert_tool(tool=langchain_tool, type=\"langchain\")\n", + "\n", + "ag2_tool.register_for_execution(user_proxy)\n", + "ag2_tool.register_for_llm(chatbot)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "message = \"Tell me about the history of the United States\"\n", + "user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## CrewAI Tools Integration\n", + "\n", + "CrewAI provides a variety of powerful tools designed for tasks such as web scraping, search, code interpretation, and more. These tools are easy to integrate into the AG2 framework, allowing you to enhance your agents with advanced capabilities. You can explore the full list of available tools in the [CrewAI Tools](https://github.com/crewAIInc/crewAI-tools/tree/main) repository.\n", + "\n", + "### Installation\n", + "Install the required packages for integrating CrewAI tools into the AG2 framework.\n", + "This ensures all dependencies for both frameworks are installed.\n", + "\n", + "```bash\n", + "pip install ag2[interop-crewai]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports\n", + "\n", + "Import necessary modules and tools.\n", + "- `ScrapeWebsiteTool` are the CrewAI tools for web scraping\n", + "- `AssistantAgent` and `UserProxyAgent` are core AG2 classes.\n", + "- `Interoperability`: This module acts as a bridge, making it easier to integrate CrewAI tools with AG2’s architecture." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "from crewai_tools import ScrapeWebsiteTool\n", + "\n", + "from autogen import AssistantAgent, UserProxyAgent\n", + "from autogen.interop import Interoperability" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Agent Configuration\n", + "\n", + "Configure the agents for the interaction.\n", + "- `config_list` defines the LLM configurations, including the model and API key.\n", + "- `UserProxyAgent` simulates user inputs without requiring actual human interaction (set to `NEVER`).\n", + "- `AssistantAgent` represents the AI agent, configured with the LLM settings." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "config_list = [{\"model\": \"gpt-4o\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", + "user_proxy = UserProxyAgent(\n", + " name=\"User\",\n", + " human_input_mode=\"NEVER\",\n", + ")\n", + "\n", + "chatbot = AssistantAgent(\n", + " name=\"chatbot\",\n", + " llm_config={\"config_list\": config_list},\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tool Integration\n", + "\n", + "Initialize and register the CrewAI tool with AG2.\n", + "- `crewai_tool` is an instance of the `ScrapeWebsiteTool` from CrewAI.\n", + "- `Interoperability` converts the CrewAI tool to make it usable in AG2.\n", + "- `register_for_execution` and `register_for_llm` allow the tool to work with the UserProxyAgent and AssistantAgent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "interop = Interoperability()\n", + "crewai_tool = ScrapeWebsiteTool()\n", + "ag2_tool = interop.convert_tool(tool=crewai_tool, type=\"crewai\")\n", + "\n", + "ag2_tool.register_for_execution(user_proxy)\n", + "ag2_tool.register_for_llm(chatbot)\n", + "\n", + "message = \"Scrape the website https://ag2.ai/\"\n", + "\n", + "chat_result = user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(chat_result.summary)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PydanticAI Tools Integration\n", + "\n", + "[PydanticAI](https://ai.pydantic.dev/) is a newer framework that offers powerful capabilities for working with LLMs. Although it currently does not have a repository with pre-built tools, it provides features like **dependency injection**, allowing you to inject a \"Context\" into a tool for better execution without relying on LLMs. This context can be used for passing parameters or managing state during the execution of a tool. While the framework is still growing, you can integrate its tools into AG2 to enhance agent capabilities, especially for tasks that involve structured data and context-driven logic.\n", + "\n", + "### Installation\n", + "To integrate LangChain tools into the AG2 framework, install the required dependencies:\n", + "\n", + "```bash\n", + "pip install ag2[interop-pydantic-ai]\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports\n", + "\n", + "Import necessary modules and tools.\n", + "- `BaseModel`: Used to define data structures for tool inputs and outputs.\n", + "- `RunContext`: Provides context during the execution of tools.\n", + "- `PydanticAITool`: Represents a tool in the PydanticAI framework.\n", + "- `AssistantAgent` and `UserProxyAgent`: Agents that facilitate communication in the AG2 framework.\n", + "- `Interoperability`: This module acts as a bridge, making it easier to integrate PydanticAI tools with AG2’s architecture." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from typing import Optional\n", + "\n", + "from pydantic import BaseModel\n", + "from pydantic_ai import RunContext\n", + "from pydantic_ai.tools import Tool as PydanticAITool\n", + "\n", + "from autogen import AssistantAgent, UserProxyAgent\n", + "from autogen.interop import Interoperability" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Agent Configuration\n", + "\n", + "Configure the agents for the interaction.\n", + "- `config_list` defines the LLM configurations, including the model and API key.\n", + "- `UserProxyAgent` simulates user inputs without requiring actual human interaction (set to `NEVER`).\n", + "- `AssistantAgent` represents the AI agent, configured with the LLM settings." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "config_list = [{\"model\": \"gpt-4o\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", + "user_proxy = UserProxyAgent(\n", + " name=\"User\",\n", + " human_input_mode=\"NEVER\",\n", + ")\n", + "\n", + "chatbot = AssistantAgent(\n", + " name=\"chatbot\",\n", + " llm_config={\"config_list\": config_list},\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tool Integration\n", + "\n", + "Integrate the PydanticAI tool with AG2.\n", + "\n", + "- Define a `Player` model using `BaseModel` to structure the input data.\n", + "- Use `RunContext` to securely inject dependencies (like the `Player` instance) into the tool function without exposing them to the LLM.\n", + "- Implement `get_player` to define the tool's functionality, accessing `ctx.deps` for injected data.\n", + "- Convert the tool to an AG2-compatible format with `Interoperability` and register it for execution and LLM communication.\n", + "- Convert the PydanticAI tool into an AG2-compatible format using `convert_tool`.\n", + "- Register the tool for both execution and communication with the LLM by associating it with the `user_proxy` and `chatbot`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "class Player(BaseModel):\n", + " name: str\n", + " age: int\n", + "\n", + "\n", + "def get_player(ctx: RunContext[Player], additional_info: Optional[str] = None) -> str: # type: ignore[valid-type]\n", + " \"\"\"Get the player's name.\n", + "\n", + " Args:\n", + " additional_info: Additional information which can be used.\n", + " \"\"\"\n", + " return f\"Name: {ctx.deps.name}, Age: {ctx.deps.age}, Additional info: {additional_info}\" # type: ignore[attr-defined]\n", + "\n", + "\n", + "interop = Interoperability()\n", + "pydantic_ai_tool = PydanticAITool(get_player, takes_ctx=True)\n", + "\n", + "# player will be injected as a dependency\n", + "player = Player(name=\"Luka\", age=25)\n", + "ag2_tool = interop.convert_tool(tool=pydantic_ai_tool, type=\"pydanticai\", deps=player)\n", + "\n", + "ag2_tool.register_for_execution(user_proxy)\n", + "ag2_tool.register_for_llm(chatbot)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initiate a conversation between the `UserProxyAgent` and the `AssistantAgent`.\n", + "\n", + "- Use the `initiate_chat` method to send a message from the `user_proxy` to the `chatbot`.\n", + "- In this example, the user requests the chatbot to retrieve player information, providing \"goal keeper\" as additional context.\n", + "- The `Player` instance is securely injected into the tool using `RunContext`, ensuring the chatbot can retrieve and use this data during the interaction." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "user_proxy.initiate_chat(\n", + " recipient=chatbot, message=\"Get player, for additional information use 'goal keeper'\", max_turns=3\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 659ca04752992bc1a56ba2d6570f1296c1fbba90 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Thu, 19 Dec 2024 12:19:48 +0100 Subject: [PATCH 52/70] Add docstrings --- autogen/interop/crewai/crewai.py | 25 ++++++++++ autogen/interop/interoperability.py | 55 ++++++++++++++++++++++ autogen/interop/interoperable.py | 22 ++++++++- autogen/interop/langchain/langchain.py | 27 +++++++++++ autogen/interop/pydantic_ai/pydantic_ai.py | 47 ++++++++++++++++++ autogen/tools/pydantic_ai_tool.py | 33 +++++++++++++ autogen/tools/tool.py | 30 ++++++++++++ 7 files changed, 238 insertions(+), 1 deletion(-) diff --git a/autogen/interop/crewai/crewai.py b/autogen/interop/crewai/crewai.py index 240ec47960..97abda9e77 100644 --- a/autogen/interop/crewai/crewai.py +++ b/autogen/interop/crewai/crewai.py @@ -18,7 +18,32 @@ def _sanitize_name(s: str) -> str: class CrewAIInteroperability(Interoperable): + """ + A class implementing the `Interoperable` protocol for converting CrewAI tools + to a general `Tool` format. + + This class takes a `CrewAITool` and converts it into a standard `Tool` object. + """ + def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: + """ + Converts a given CrewAI tool into a general `Tool` format. + + This method ensures that the provided tool is a valid `CrewAITool`, sanitizes + the tool's name, processes its description, and prepares a function to interact + with the tool's arguments. It then returns a standardized `Tool` object. + + Args: + tool (Any): The tool to convert, expected to be an instance of `CrewAITool`. + **kwargs (Any): Additional arguments, which are not supported by this method. + + Returns: + Tool: A standardized `Tool` object converted from the CrewAI tool. + + Raises: + ValueError: If the provided tool is not an instance of `CrewAITool`, or if + any additional arguments are passed. + """ if not isinstance(tool, CrewAITool): raise ValueError(f"Expected an instance of `crewai.tools.BaseTool`, got {type(tool)}") if kwargs: diff --git a/autogen/interop/interoperability.py b/autogen/interop/interoperability.py index 68190fbf04..27df3cd9c7 100644 --- a/autogen/interop/interoperability.py +++ b/autogen/interop/interoperability.py @@ -11,28 +11,83 @@ class Interoperability: + """ + A class to handle interoperability between different tool types. + + This class allows the conversion of tools to various interoperability classes and provides functionality + for retrieving and registering interoperability classes. + """ + _interoperability_classes: Dict[str, Type[Interoperable]] = get_all_interoperability_classes() def __init__(self) -> None: + """ + Initializes an instance of the Interoperability class. + + This constructor does not perform any specific actions as the class is primarily used for its class + methods to manage interoperability classes. + """ pass def convert_tool(self, *, tool: Any, type: str, **kwargs: Any) -> Tool: + """ + Converts a given tool to an instance of a specified interoperability type. + + Args: + tool (Any): The tool object to be converted. + type (str): The type of interoperability to convert the tool to. + **kwargs (Any): Additional arguments to be passed during conversion. + + Returns: + Tool: The converted tool. + + Raises: + ValueError: If the interoperability class for the provided type is not found. + """ interop_cls = self.get_interoperability_class(type) interop = interop_cls() return interop.convert_tool(tool, **kwargs) @classmethod def get_interoperability_class(cls, type: str) -> Type[Interoperable]: + """ + Retrieves the interoperability class corresponding to the specified type. + + Args: + type (str): The type of the interoperability class to retrieve. + + Returns: + Type[Interoperable]: The interoperability class type. + + Raises: + ValueError: If no interoperability class is found for the provided type. + """ if type not in cls._interoperability_classes: raise ValueError(f"Interoperability class {type} not found") return cls._interoperability_classes[type] @classmethod def supported_types(cls) -> List[str]: + """ + Returns a sorted list of all supported interoperability types. + + Returns: + List[str]: A sorted list of strings representing the supported interoperability types. + """ return sorted(cls._interoperability_classes.keys()) @classmethod def register_interoperability_class(cls, name: str, interoperability_class: Type[Interoperable]) -> None: + """ + Registers a new interoperability class with the given name. + + Args: + name (str): The name to associate with the interoperability class. + interoperability_class (Type[Interoperable]): The class implementing the Interoperable protocol. + + Raises: + ValueError: If the provided class does not implement the Interoperable protocol. + """ if not issubclass(interoperability_class, Interoperable): raise ValueError( f"Expected a class implementing `Interoperable` protocol, got {type(interoperability_class)}" diff --git a/autogen/interop/interoperable.py b/autogen/interop/interoperable.py index 1b9bed1405..75aefaaf25 100644 --- a/autogen/interop/interoperable.py +++ b/autogen/interop/interoperable.py @@ -11,4 +11,24 @@ @runtime_checkable class Interoperable(Protocol): - def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: ... + """ + A Protocol defining the interoperability interface for tool conversion. + + This protocol ensures that any class implementing it provides the method + `convert_tool` to convert a given tool into a desired format or type. + """ + + def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: + """ + Converts a given tool to a desired format or type. + + This method should be implemented by any class adhering to the `Interoperable` protocol. + + Args: + tool (Any): The tool object to be converted. + **kwargs (Any): Additional parameters to pass during the conversion process. + + Returns: + Tool: The converted tool in the desired format or type. + """ + ... diff --git a/autogen/interop/langchain/langchain.py b/autogen/interop/langchain/langchain.py index 1507796c5d..925e00431a 100644 --- a/autogen/interop/langchain/langchain.py +++ b/autogen/interop/langchain/langchain.py @@ -13,7 +13,34 @@ class LangchainInteroperability(Interoperable): + """ + A class implementing the `Interoperable` protocol for converting Langchain tools + into a general `Tool` format. + + This class takes a `LangchainTool` and converts it into a standard `Tool` object, + ensuring compatibility between Langchain tools and other systems that expect + the `Tool` format. + """ + def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: + """ + Converts a given Langchain tool into a general `Tool` format. + + This method verifies that the provided tool is a valid `LangchainTool`, + processes the tool's input and description, and returns a standardized + `Tool` object. + + Args: + tool (Any): The tool to convert, expected to be an instance of `LangchainTool`. + **kwargs (Any): Additional arguments, which are not supported by this method. + + Returns: + Tool: A standardized `Tool` object converted from the Langchain tool. + + Raises: + ValueError: If the provided tool is not an instance of `LangchainTool`, or if + any additional arguments are passed. + """ if not isinstance(tool, LangchainTool): raise ValueError(f"Expected an instance of `langchain_core.tools.BaseTool`, got {type(tool)}") if kwargs: diff --git a/autogen/interop/pydantic_ai/pydantic_ai.py b/autogen/interop/pydantic_ai/pydantic_ai.py index fe778ea904..b170ccf501 100644 --- a/autogen/interop/pydantic_ai/pydantic_ai.py +++ b/autogen/interop/pydantic_ai/pydantic_ai.py @@ -18,11 +18,38 @@ class PydanticAIInteroperability(Interoperable): + """ + A class implementing the `Interoperable` protocol for converting Pydantic AI tools + into a general `Tool` format. + + This class takes a `PydanticAITool` and converts it into a standard `Tool` object, + ensuring compatibility between Pydantic AI tools and other systems that expect + the `Tool` format. It also provides a mechanism for injecting context parameters + into the tool's function. + """ + @staticmethod def inject_params( # type: ignore[no-any-unimported] ctx: Optional[RunContext[Any]], tool: PydanticAITool, ) -> Callable[..., Any]: + """ + Wraps the tool's function to inject context parameters and handle retries. + + This method ensures that context parameters are properly passed to the tool + when invoked and that retries are managed according to the tool's settings. + + Args: + ctx (Optional[RunContext[Any]]): The run context, which may include dependencies + and retry information. + tool (PydanticAITool): The Pydantic AI tool whose function is to be wrapped. + + Returns: + Callable[..., Any]: A wrapped function that includes context injection and retry handling. + + Raises: + ValueError: If the tool fails after the maximum number of retries. + """ max_retries = tool.max_retries if tool.max_retries is not None else 1 f = tool.function @@ -56,6 +83,26 @@ def wrapper(*args: Any, **kwargs: Any) -> Any: return wrapper def convert_tool(self, tool: Any, deps: Any = None, **kwargs: Any) -> AG2PydanticAITool: + """ + Converts a given Pydantic AI tool into a general `Tool` format. + + This method verifies that the provided tool is a valid `PydanticAITool`, + handles context dependencies if necessary, and returns a standardized `Tool` object. + + Args: + tool (Any): The tool to convert, expected to be an instance of `PydanticAITool`. + deps (Any, optional): The dependencies to inject into the context, required if + the tool takes a context. Defaults to None. + **kwargs (Any): Additional arguments that are not used in this method. + + Returns: + AG2PydanticAITool: A standardized `Tool` object converted from the Pydantic AI tool. + + Raises: + ValueError: If the provided tool is not an instance of `PydanticAITool`, or if + dependencies are missing for tools that require a context. + UserWarning: If the `deps` argument is provided for a tool that does not take a context. + """ if not isinstance(tool, PydanticAITool): raise ValueError(f"Expected an instance of `pydantic_ai.tools.Tool`, got {type(tool)}") diff --git a/autogen/tools/pydantic_ai_tool.py b/autogen/tools/pydantic_ai_tool.py index 5c999eba3a..a106cd4b70 100644 --- a/autogen/tools/pydantic_ai_tool.py +++ b/autogen/tools/pydantic_ai_tool.py @@ -12,9 +12,33 @@ class PydanticAITool(Tool): + """ + A class representing a Pydantic AI Tool that extends the general Tool functionality + with additional functionality specific to Pydantic AI tools. + + This class inherits from the Tool class and adds functionality for registering + tools with a ConversableAgent, along with providing additional schema information + specific to Pydantic AI tools, such as parameters and function signatures. + + Attributes: + parameters_json_schema (Dict[str, Any]): A schema describing the parameters + that the tool's function expects. + """ + def __init__( self, name: str, description: str, func: Callable[..., Any], parameters_json_schema: Dict[str, Any] ) -> None: + """ + Initializes a PydanticAITool object with the provided name, description, + function, and parameter schema. + + Args: + name (str): The name of the tool. + description (str): A description of what the tool does. + func (Callable[..., Any]): The function that is executed when the tool is called. + parameters_json_schema (Dict[str, Any]): A schema describing the parameters + that the function accepts. + """ super().__init__(name, description, func) self._func_schema = { "type": "function", @@ -26,4 +50,13 @@ def __init__( } def register_for_llm(self, agent: ConversableAgent) -> None: + """ + Registers the tool with the ConversableAgent for use with a language model (LLM). + + This method updates the agent's tool signature to include the function schema, + allowing the agent to invoke the tool correctly during interactions with the LLM. + + Args: + agent (ConversableAgent): The agent with which the tool will be registered. + """ agent.update_tool_signature(self._func_schema, is_remove=False) diff --git a/autogen/tools/tool.py b/autogen/tools/tool.py index b01367235c..c0e615f37c 100644 --- a/autogen/tools/tool.py +++ b/autogen/tools/tool.py @@ -16,6 +16,18 @@ class Tool: + """ + A class representing a Tool that can be used by an agent for various tasks. + + This class encapsulates a tool with a name, description, and an executable function. + The tool can be registered with a ConversableAgent for use either with an LLM or for direct execution. + + Attributes: + name (str): The name of the tool. + description (str): A brief description of the tool's purpose or function. + func (Callable[..., Any]): The function to be executed when the tool is called. + """ + def __init__(self, name: str, description: str, func: Callable[..., Any]) -> None: """Create a new Tool object. @@ -41,7 +53,25 @@ def func(self) -> Callable[..., Any]: return self._func def register_for_llm(self, agent: ConversableAgent) -> None: + """ + Registers the tool for use with a ConversableAgent's language model (LLM). + + This method registers the tool so that it can be invoked by the agent during + interactions with the language model. + + Args: + agent (ConversableAgent): The agent to which the tool will be registered. + """ agent.register_for_llm(name=self._name, description=self._description)(self._func) def register_for_execution(self, agent: ConversableAgent) -> None: + """ + Registers the tool for direct execution by a ConversableAgent. + + This method registers the tool so that it can be executed by the agent, + typically outside of the context of an LLM interaction. + + Args: + agent (ConversableAgent): The agent to which the tool will be registered. + """ agent.register_for_execution(name=self._name)(self._func) From 56d5939ec49936c290878d557a95d982d7ad9564 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 19 Dec 2024 12:23:42 +0100 Subject: [PATCH 53/70] fixes Signed-off-by: Davor Runje --- =8 | 6 +++ autogen/interop/__init__.py | 3 +- autogen/interop/langchain/langchain.py | 4 +- autogen/interop/registry.py | 62 ++++++++++++++++++++++++++ setup.py | 7 ++- 5 files changed, 77 insertions(+), 5 deletions(-) create mode 100644 =8 create mode 100644 autogen/interop/registry.py diff --git a/=8 b/=8 new file mode 100644 index 0000000000..d47c38ce90 --- /dev/null +++ b/=8 @@ -0,0 +1,6 @@ +Requirement already satisfied: pytest in ./.venv-3.9/lib/python3.9/site-packages (7.4.4) +Requirement already satisfied: iniconfig in ./.venv-3.9/lib/python3.9/site-packages (from pytest) (2.0.0) +Requirement already satisfied: packaging in ./.venv-3.9/lib/python3.9/site-packages (from pytest) (24.2) +Requirement already satisfied: pluggy<2.0,>=0.12 in ./.venv-3.9/lib/python3.9/site-packages (from pytest) (1.5.0) +Requirement already satisfied: exceptiongroup>=1.0.0rc8 in ./.venv-3.9/lib/python3.9/site-packages (from pytest) (1.2.2) +Requirement already satisfied: tomli>=1.0.0 in ./.venv-3.9/lib/python3.9/site-packages (from pytest) (2.2.1) diff --git a/autogen/interop/__init__.py b/autogen/interop/__init__.py index 90c5f92d7b..fd742ccc69 100644 --- a/autogen/interop/__init__.py +++ b/autogen/interop/__init__.py @@ -4,5 +4,6 @@ from .interoperability import Interoperability from .interoperable import Interoperable +from .registry import register_interoperable_class -__all__ = ["Interoperable", "Interoperability"] +__all__ = ["Interoperability", "Interoperable", "register_interoperable_class"] diff --git a/autogen/interop/langchain/langchain.py b/autogen/interop/langchain/langchain.py index b3f4713c63..71f339205c 100644 --- a/autogen/interop/langchain/langchain.py +++ b/autogen/interop/langchain/langchain.py @@ -18,9 +18,9 @@ def convert_tool(self, tool: Any) -> Tool: raise ValueError(f"Expected an instance of `langchain_core.tools.BaseTool`, got {type(tool)}") # needed for type checking - langchain_tool: LangchainTool = tool # type: ignore[no-any-unimported] + langchain_tool: LangchainTool = tool - def func(tool_input: langchain_tool.args_schema) -> Any: # type: ignore[no-any-unimported] + def func(tool_input: langchain_tool.args_schema) -> Any: # type: ignore[name-defined] return langchain_tool.run(tool_input.model_dump()) return Tool( diff --git a/autogen/interop/registry.py b/autogen/interop/registry.py new file mode 100644 index 0000000000..949182eeaa --- /dev/null +++ b/autogen/interop/registry.py @@ -0,0 +1,62 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +from typing import Callable, Dict, Generic, List, Type, TypeVar + +from .interoperable import Interoperable + +__all__ = ["register_interoperable_class"] + +InteroperableClass = TypeVar("InteroperableClass", bound=Type[Interoperable]) + + +class _InteroperableRegistry: + def __init__(self) -> None: + self._registry: Dict[str, Type[Interoperable]] = {} + + def register(self, short_name: str, cls: InteroperableClass) -> InteroperableClass: + if short_name in self._registry: + raise ValueError(f"Duplicate registration for {short_name}") + + self._registry[short_name] = cls + + return cls + + def get_short_names(self) -> List[str]: + return sorted(self._registry.keys()) + + def get_class(self, short_name: str) -> Type[Interoperable]: + return self._registry[short_name] + + @classmethod + def get_instance(cls) -> "_InteroperableRegistry": + return _register + + +# global registry +_register = _InteroperableRegistry() + + +# register decorator +def register_interoperable_class(short_name: str) -> Callable[[InteroperableClass], InteroperableClass]: + """Register an Interoperable class in the global registry. + + Returns: + Callable[[InteroperableClass], InteroperableClass]: Decorator function + + Example: + ```python + @register_interoperable_class("myinterop") + class MyInteroperability(Interoperable): + def convert_tool(self, tool: Any) -> Tool: + # implementation + ... + ``` + """ + + def inner(cls: InteroperableClass) -> InteroperableClass: + global _register + return _register.register(short_name, cls) + + return inner diff --git a/setup.py b/setup.py index 63cade834a..1c6df70eec 100644 --- a/setup.py +++ b/setup.py @@ -72,6 +72,9 @@ interop_crewai = ["crewai[tools]>=0.86,<1; python_version>='3.10' and python_version<'3.13'"] interop_langchain = ["langchain-community>=0.3.12,<1; python_version>='3.9'"] interop_pydantic_ai = ["pydantic-ai>=0.0.13,<1; python_version>='3.9'"] +interop = interop_crewai + interop_langchain + interop_pydantic_ai + +types = (["mypy==1.9.0", "pytest>=6.1.1,<8"] + jupyter_executor + interop,) if current_os in ["Windows", "Darwin"]: retrieve_chat_pgvector.extend(["psycopg[binary]>=3.1.18"]) @@ -117,7 +120,7 @@ "cosmosdb": ["azure-cosmos>=4.2.0"], "websockets": ["websockets>=12.0,<13"], "jupyter-executor": jupyter_executor, - "types": ["mypy==1.9.0", "pytest>=6.1.1,<8"] + jupyter_executor, + "types": types, "long-context": ["llmlingua<0.3"], "anthropic": ["anthropic>=0.23.1"], "cerebras": ["cerebras_cloud_sdk>=1.0.0"], @@ -129,7 +132,7 @@ "interop-crewai": interop_crewai, "interop-langchain": interop_langchain, "interop-pydantic-ai": interop_pydantic_ai, - "interop": interop_crewai + interop_langchain + interop_pydantic_ai, + "interop": interop, "neo4j": neo4j, } From b41328fac28d461c2e853b280f94401997728016 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Thu, 19 Dec 2024 12:27:31 +0100 Subject: [PATCH 54/70] Remove notebooks --- notebook/tools_crewai_tools_integration.ipynb | 190 ------------------ .../tools_langchain_tools_integration.ipynb | 168 ---------------- .../tools_pydantic_ai_tools_integration.ipynb | 183 ----------------- 3 files changed, 541 deletions(-) delete mode 100644 notebook/tools_crewai_tools_integration.ipynb delete mode 100644 notebook/tools_langchain_tools_integration.ipynb delete mode 100644 notebook/tools_pydantic_ai_tools_integration.ipynb diff --git a/notebook/tools_crewai_tools_integration.ipynb b/notebook/tools_crewai_tools_integration.ipynb deleted file mode 100644 index 553025a43f..0000000000 --- a/notebook/tools_crewai_tools_integration.ipynb +++ /dev/null @@ -1,190 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Integrating CrewAI Tools with the AG2 Framework\n", - "\n", - "In this tutorial, we demonstrate how to integrate [CrewAI Tools](https://github.com/crewAIInc/crewAI-tools/tree/main) into the AG2 framework. This process enables smooth interoperability between the two systems, allowing developers to leverage CrewAI's powerful tools within AG2's flexible agent-based architecture. By the end of this guide, you will understand how to configure agents, convert CrewAI tools for use in AG2, and validate the integration with a practical example.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Installation\n", - "Install the required packages for integrating CrewAI tools into the AG2 framework.\n", - "This ensures all dependencies for both frameworks are installed.\n", - "\n", - "```bash\n", - "pip install ag2[interop-crewai]\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports\n", - "\n", - "Import necessary modules and tools.\n", - "- `os` is used to access environment variables.\n", - "- `Path` helps in handling file paths.\n", - "- `TemporaryDirectory` is used for creating a temporary workspace.\n", - "- `FileWriterTool` and `ScrapeWebsiteTool` are the CrewAI tools we will integrate.\n", - "- `AssistantAgent` and `UserProxyAgent` are core AG2 classes.\n", - "- `CrewAIInteroperability` facilitates the interoperability between AG2 and CrewAI." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "from pathlib import Path\n", - "from tempfile import TemporaryDirectory\n", - "\n", - "from crewai_tools import FileWriterTool, ScrapeWebsiteTool\n", - "\n", - "from autogen import AssistantAgent, UserProxyAgent\n", - "from autogen.interop.crewai import CrewAIInteroperability" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Agent Configuration\n", - "\n", - "Configure the agents for the interaction.\n", - "- `config_list` defines the LLM configurations, including the model and API key.\n", - "- `UserProxyAgent` simulates user inputs without requiring actual human interaction (set to `NEVER`).\n", - "- `AssistantAgent` represents the AI agent, configured with the LLM settings." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "config_list = [{\"model\": \"gpt-4o-mini\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", - "user_proxy = UserProxyAgent(\n", - " name=\"User\",\n", - " human_input_mode=\"NEVER\",\n", - ")\n", - "\n", - "chatbot = AssistantAgent(\n", - " name=\"chatbot\",\n", - " llm_config={\"config_list\": config_list},\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Tool Integration\n", - "\n", - "Initialize and register the CrewAI tool with AG2.\n", - "- `crewai_tool` is an instance of the `FileWriterTool` from CrewAI.\n", - "- `CrewAIInteroperability` converts the CrewAI tool to make it usable in AG2.\n", - "- `register_for_execution` and `register_for_llm` allow the tool to work with the UserProxyAgent and AssistantAgent." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "crewai_tool = FileWriterTool()\n", - "crewai_interop = CrewAIInteroperability()\n", - "ag2_tool = crewai_interop.convert_tool(crewai_tool)\n", - "\n", - "ag2_tool.register_for_execution(user_proxy)\n", - "ag2_tool.register_for_llm(chatbot)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## File creation\n", - "\n", - "Demonstrate the integration by writing to a file using the converted CrewAI tool.\n", - "- A temporary directory is created to simulate a file operation environment.\n", - "- The `message` instructs the chatbot to use the tool to write a specific string into a file.\n", - "- `user_proxy.initiate_chat` starts the interaction, with the chatbot processing the request and using the tool.\n", - "- Finally, the output file is verified to ensure the integration works correctly." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "with TemporaryDirectory() as tmpdirname:\n", - " filename = \"tool_result.txt\"\n", - " message = f\"\"\"Write 'Easy Migration :)' into {filename}.\n", - "Use {tmpdirname} dir.\n", - "\"\"\"\n", - "\n", - " user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)\n", - "\n", - " assert Path(tmpdirname, filename).read_text() == \"Easy Migration :)\"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "crewai_scrape_tool = ScrapeWebsiteTool()\n", - "ag2_tool = crewai_interop.convert_tool(crewai_scrape_tool)\n", - "\n", - "ag2_tool.register_for_execution(user_proxy)\n", - "ag2_tool.register_for_llm(chatbot)\n", - "\n", - "message = \"Scrape the website https://ag2.ai/\"\n", - "\n", - "chat_result = user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(chat_result.summary)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebook/tools_langchain_tools_integration.ipynb b/notebook/tools_langchain_tools_integration.ipynb deleted file mode 100644 index 48a1d0986a..0000000000 --- a/notebook/tools_langchain_tools_integration.ipynb +++ /dev/null @@ -1,168 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Integrating LangChain Tools with the AG2 Framework\n", - "\n", - "In this tutorial, we demonstrate how to integrate [LangChain Tools](https://python.langchain.com/v0.1/docs/modules/tools) into the AG2 framework. This process enables smooth interoperability between the two systems, allowing developers to leverage LangChain's powerful tools within AG2's flexible agent-based architecture. By the end of this guide, you will understand how to configure agents, convert LangChain tools for use in AG2, and validate the integration with a practical example.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Installation\n", - "To integrate LangChain tools into the AG2 framework, install the required dependencies:\n", - "\n", - "```bash\n", - "pip install ag2[interop-langchain]\n", - "```\n", - "\n", - "Additionally, this notebook uses LangChain's [Wikipedia Tool](https://api.python.langchain.com/en/latest/tools/langchain_community.tools.wikipedia.tool.WikipediaQueryRun.html), which requires the `wikipedia` package. Install it with:\n", - "\n", - "```bash\n", - "pip install wikipedia\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports\n", - "\n", - "Import necessary modules and tools.\n", - "- `os`: For accessing environment variables.\n", - "- `WikipediaQueryRun` and `WikipediaAPIWrapper`: Tools for querying Wikipedia.\n", - "- `AssistantAgent` and `UserProxyAgent`: Agents that facilitate communication in the AG2 framework.\n", - "- `LangchainInteroperability`: A bridge for integrating LangChain tools with the AG2 framework." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "\n", - "from langchain_community.tools import WikipediaQueryRun\n", - "from langchain_community.utilities import WikipediaAPIWrapper\n", - "\n", - "from autogen import AssistantAgent, UserProxyAgent\n", - "from autogen.interop.langchain import LangchainInteroperability" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Agent Configuration\n", - "\n", - "Configure the agents for the interaction.\n", - "- `config_list` defines the LLM configurations, including the model and API key.\n", - "- `UserProxyAgent` simulates user inputs without requiring actual human interaction (set to `NEVER`).\n", - "- `AssistantAgent` represents the AI agent, configured with the LLM settings." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "config_list = [{\"model\": \"gpt-4o\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", - "user_proxy = UserProxyAgent(\n", - " name=\"User\",\n", - " human_input_mode=\"NEVER\",\n", - ")\n", - "\n", - "chatbot = AssistantAgent(\n", - " name=\"chatbot\",\n", - " llm_config={\"config_list\": config_list},\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Tool Integration\n", - "\n", - "- Initialize and register the LangChain tool with AG2.\n", - "- `WikipediaAPIWrapper`: Configured to fetch the top 1 result from Wikipedia with a maximum of 1000 characters per document.\n", - "- `WikipediaQueryRun`: A LangChain tool that executes Wikipedia queries.\n", - "- `LangchainInteroperability`: Converts the LangChain tool into a format compatible with the AG2 framework.\n", - "- `ag2_tool.register_for_execution(user_proxy)`: Registers the tool for use by the user_proxy agent.\n", - "- `ag2_tool.register_for_llm(chatbot)`: Registers the tool for integration with the chatbot agent.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=1000)\n", - "langchain_tool = WikipediaQueryRun(api_wrapper=api_wrapper)\n", - "\n", - "langchain_interop = LangchainInteroperability()\n", - "ag2_tool = langchain_interop.convert_tool(langchain_tool)\n", - "\n", - "ag2_tool.register_for_execution(user_proxy)\n", - "ag2_tool.register_for_llm(chatbot)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Wikipedia Browsing\n", - "\n", - "- `user_proxy` queries the `chatbot`, which uses a Wikipedia tool to retrieve information.\n", - "- The `chatbot` identifies the query's intent and fetches a summary from Wikipedia.\n", - "- Tool execution returns a concise response from the relevant Wikipedia page." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "message = \"Tell me about the history of the United States\"\n", - "user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebook/tools_pydantic_ai_tools_integration.ipynb b/notebook/tools_pydantic_ai_tools_integration.ipynb deleted file mode 100644 index edf2170135..0000000000 --- a/notebook/tools_pydantic_ai_tools_integration.ipynb +++ /dev/null @@ -1,183 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Integrating PydanticAI Tools with the AG2 Framework\n", - "\n", - "In this tutorial, we demonstrate how to integrate [PydanticAI Tools](https://ai.pydantic.dev/tools/) into the AG2 framework. This process enables smooth interoperability between the two systems, allowing developers to leverage PydanticAI's powerful tools within AG2's flexible agent-based architecture. By the end of this guide, you will understand how to configure agents, convert PydanticAI tools for use in AG2, and validate the integration with a practical example.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Installation\n", - "To integrate LangChain tools into the AG2 framework, install the required dependencies:\n", - "\n", - "```bash\n", - "pip install ag2[interop-pydantic-ai]\n", - "```\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Imports\n", - "\n", - "Import necessary modules and tools.\n", - "- `BaseModel`: Used to define data structures for tool inputs and outputs.\n", - "- `RunContext`: Provides context during the execution of tools.\n", - "- `PydanticAITool`: Represents a tool in the PydanticAI framework.\n", - "- `AssistantAgent` and `UserProxyAgent`: Agents that facilitate communication in the AG2 framework.\n", - "- `PydanticAIInteroperability`: A bridge for integrating PydanticAI tools with the AG2 framework." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "from typing import Optional\n", - "\n", - "from pydantic import BaseModel\n", - "from pydantic_ai import RunContext\n", - "from pydantic_ai.tools import Tool as PydanticAITool\n", - "\n", - "from autogen import AssistantAgent, UserProxyAgent\n", - "from autogen.interop.pydantic_ai import PydanticAIInteroperability" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Agent Configuration\n", - "\n", - "Configure the agents for the interaction.\n", - "- `config_list` defines the LLM configurations, including the model and API key.\n", - "- `UserProxyAgent` simulates user inputs without requiring actual human interaction (set to `NEVER`).\n", - "- `AssistantAgent` represents the AI agent, configured with the LLM settings." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "config_list = [{\"model\": \"gpt-4o\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}]\n", - "user_proxy = UserProxyAgent(\n", - " name=\"User\",\n", - " human_input_mode=\"NEVER\",\n", - ")\n", - "\n", - "chatbot = AssistantAgent(\n", - " name=\"chatbot\",\n", - " llm_config={\"config_list\": config_list},\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Tool Integration\n", - "\n", - "Integrate the PydanticAI tool with AG2.\n", - "\n", - "- Define a `Player` model using `BaseModel` to structure the input data.\n", - "- Use `RunContext` to securely inject dependencies (like the `Player` instance) into the tool function without exposing them to the LLM.\n", - "- Implement `get_player` to define the tool's functionality, accessing `ctx.deps` for injected data.\n", - "- Convert the tool to an AG2-compatible format with `PydanticAIInteroperability` and register it for execution and LLM communication.\n", - "- Convert the PydanticAI tool into an AG2-compatible format using `convert_tool`.\n", - "- Register the tool for both execution and communication with the LLM by associating it with the `user_proxy` and `chatbot`." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "class Player(BaseModel):\n", - " name: str\n", - " age: int\n", - "\n", - "\n", - "def get_player(ctx: RunContext[Player], additional_info: Optional[str] = None) -> str: # type: ignore[valid-type]\n", - " \"\"\"Get the player's name.\n", - "\n", - " Args:\n", - " additional_info: Additional information which can be used.\n", - " \"\"\"\n", - " return f\"Name: {ctx.deps.name}, Age: {ctx.deps.age}, Additional info: {additional_info}\" # type: ignore[attr-defined]\n", - "\n", - "\n", - "pydantic_ai_interop = PydanticAIInteroperability()\n", - "pydantic_ai_tool = PydanticAITool(get_player, takes_ctx=True)\n", - "\n", - "# player will be injected as a dependency\n", - "player = Player(name=\"Luka\", age=25)\n", - "ag2_tool = pydantic_ai_interop.convert_tool(tool=pydantic_ai_tool, deps=player)\n", - "\n", - "ag2_tool.register_for_execution(user_proxy)\n", - "ag2_tool.register_for_llm(chatbot)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Initiate a conversation between the `UserProxyAgent` and the `AssistantAgent`.\n", - "\n", - "- Use the `initiate_chat` method to send a message from the `user_proxy` to the `chatbot`.\n", - "- In this example, the user requests the chatbot to retrieve player information, providing \"goal keeper\" as additional context.\n", - "- The `Player` instance is securely injected into the tool using `RunContext`, ensuring the chatbot can retrieve and use this data during the interaction." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "user_proxy.initiate_chat(\n", - " recipient=chatbot, message=\"Get player, for additional information use 'goal keeper'\", max_turns=3\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From bfb19b75fccd21e131c68bf07b9a0c7057fd6321 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 19 Dec 2024 12:51:48 +0100 Subject: [PATCH 55/70] fixing types Signed-off-by: Davor Runje --- autogen/interop/pydantic_ai/pydantic_ai.py | 15 +++++++-------- setup.py | 2 +- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/autogen/interop/pydantic_ai/pydantic_ai.py b/autogen/interop/pydantic_ai/pydantic_ai.py index b170ccf501..b76612d3c8 100644 --- a/autogen/interop/pydantic_ai/pydantic_ai.py +++ b/autogen/interop/pydantic_ai/pydantic_ai.py @@ -29,9 +29,9 @@ class PydanticAIInteroperability(Interoperable): """ @staticmethod - def inject_params( # type: ignore[no-any-unimported] + def inject_params( ctx: Optional[RunContext[Any]], - tool: PydanticAITool, + tool: PydanticAITool[Any], ) -> Callable[..., Any]: """ Wraps the tool's function to inject context parameters and handle retries. @@ -40,8 +40,7 @@ def inject_params( # type: ignore[no-any-unimported] when invoked and that retries are managed according to the tool's settings. Args: - ctx (Optional[RunContext[Any]]): The run context, which may include dependencies - and retry information. + ctx (Optional[RunContext[Any]]): The run context, which may include dependencies and retry information. tool (PydanticAITool): The Pydantic AI tool whose function is to be wrapped. Returns: @@ -62,9 +61,9 @@ def wrapper(*args: Any, **kwargs: Any) -> Any: if ctx is not None: kwargs.pop("ctx", None) ctx.retry = tool.current_retry - result = f(**kwargs, ctx=ctx) + result = f(**kwargs, ctx=ctx) # type: ignore[call-arg] else: - result = f(**kwargs) + result = f(**kwargs) # type: ignore[call-arg] tool.current_retry = 0 except Exception as e: tool.current_retry += 1 @@ -107,7 +106,7 @@ def convert_tool(self, tool: Any, deps: Any = None, **kwargs: Any) -> AG2Pydanti raise ValueError(f"Expected an instance of `pydantic_ai.tools.Tool`, got {type(tool)}") # needed for type checking - pydantic_ai_tool: PydanticAITool = tool # type: ignore[no-any-unimported] + pydantic_ai_tool: PydanticAITool[Any] = tool if tool.takes_ctx and deps is None: raise ValueError("If the tool takes a context, the `deps` argument must be provided") @@ -123,7 +122,7 @@ def convert_tool(self, tool: Any, deps: Any = None, **kwargs: Any) -> AG2Pydanti retry=0, # All messages send to or returned by a model. # This is mostly used on pydantic_ai Agent level. - messages=None, # TODO: check in the future if this is needed on Tool level + messages=[], # TODO: check in the future if this is needed on Tool level tool_name=pydantic_ai_tool.name, ) else: diff --git a/setup.py b/setup.py index 1c6df70eec..c438608894 100644 --- a/setup.py +++ b/setup.py @@ -74,7 +74,7 @@ interop_pydantic_ai = ["pydantic-ai>=0.0.13,<1; python_version>='3.9'"] interop = interop_crewai + interop_langchain + interop_pydantic_ai -types = (["mypy==1.9.0", "pytest>=6.1.1,<8"] + jupyter_executor + interop,) +types = (["mypy==1.9.0", "pytest"] + jupyter_executor + interop,) if current_os in ["Windows", "Darwin"]: retrieve_chat_pgvector.extend(["psycopg[binary]>=3.1.18"]) From 7641855bb1d10a5975d02b00257e4d50a41f715c Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 19 Dec 2024 13:46:41 +0100 Subject: [PATCH 56/70] refactoring Signed-off-by: Davor Runje --- autogen/interop/__init__.py | 3 + autogen/interop/crewai/__init__.py | 10 ---- autogen/interop/crewai/crewai.py | 21 ++++++- autogen/interop/helpers.py | 55 ----------------- autogen/interop/interoperability.py | 44 ++++---------- autogen/interop/interoperable.py | 13 +++- autogen/interop/langchain/__init__.py | 12 ---- autogen/interop/langchain/langchain.py | 23 +++++++- autogen/interop/pydantic_ai/__init__.py | 12 ---- autogen/interop/pydantic_ai/pydantic_ai.py | 52 +++++++++++----- autogen/interop/registry.py | 13 ++-- test/interop/crewai/test_crewai.py | 16 +++++ test/interop/test_helpers.py | 69 ---------------------- test/interop/test_interoperability.py | 25 +------- 14 files changed, 129 insertions(+), 239 deletions(-) delete mode 100644 autogen/interop/helpers.py delete mode 100644 test/interop/test_helpers.py diff --git a/autogen/interop/__init__.py b/autogen/interop/__init__.py index fd742ccc69..3afb5a529f 100644 --- a/autogen/interop/__init__.py +++ b/autogen/interop/__init__.py @@ -2,8 +2,11 @@ # # SPDX-License-Identifier: Apache-2.0 +from .crewai import CrewAIInteroperability from .interoperability import Interoperability from .interoperable import Interoperable +from .langchain import LangchainInteroperability +from .pydantic_ai import PydanticAIInteroperability from .registry import register_interoperable_class __all__ = ["Interoperability", "Interoperable", "register_interoperable_class"] diff --git a/autogen/interop/crewai/__init__.py b/autogen/interop/crewai/__init__.py index f3018b8787..50abbf3913 100644 --- a/autogen/interop/crewai/__init__.py +++ b/autogen/interop/crewai/__init__.py @@ -2,16 +2,6 @@ # # SPDX-License-Identifier: Apache-2.0 -import sys - -if sys.version_info < (3, 10) or sys.version_info >= (3, 13): - raise ImportError("This submodule is only supported for Python versions 3.10, 3.11, and 3.12") - -try: - import crewai.tools -except ImportError: - raise ImportError("Please install `interop-crewai` extra to use this module:\n\n\tpip install ag2[interop-crewai]") - from .crewai import CrewAIInteroperability __all__ = ["CrewAIInteroperability"] diff --git a/autogen/interop/crewai/crewai.py b/autogen/interop/crewai/crewai.py index 97abda9e77..43465fa875 100644 --- a/autogen/interop/crewai/crewai.py +++ b/autogen/interop/crewai/crewai.py @@ -3,12 +3,12 @@ # SPDX-License-Identifier: Apache-2.0 import re -from typing import Any, cast - -from crewai.tools import BaseTool as CrewAITool +import sys +from typing import Any, Optional, cast from ...tools import Tool from ..interoperable import Interoperable +from ..registry import register_interoperable_class __all__ = ["CrewAIInteroperability"] @@ -17,6 +17,7 @@ def _sanitize_name(s: str) -> str: return re.sub(r"\W|^(?=\d)", "_", s) +@register_interoperable_class("crewai") class CrewAIInteroperability(Interoperable): """ A class implementing the `Interoperable` protocol for converting CrewAI tools @@ -44,6 +45,8 @@ def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: ValueError: If the provided tool is not an instance of `CrewAITool`, or if any additional arguments are passed. """ + from crewai.tools import BaseTool as CrewAITool + if not isinstance(tool, CrewAITool): raise ValueError(f"Expected an instance of `crewai.tools.BaseTool`, got {type(tool)}") if kwargs: @@ -66,3 +69,15 @@ def func(args: crewai_tool.args_schema) -> Any: # type: ignore[no-any-unimporte description=description, func=func, ) + + @classmethod + def get_unsupported_reason(cls) -> Optional[str]: + if sys.version_info < (3, 10) or sys.version_info >= (3, 13): + return "This submodule is only supported for Python versions 3.10, 3.11, and 3.12" + + try: + import crewai.tools + except ImportError: + return "Please install `interop-crewai` extra to use this module:\n\n\tpip install ag2[interop-crewai]" + + return None diff --git a/autogen/interop/helpers.py b/autogen/interop/helpers.py deleted file mode 100644 index 5ec24afd9b..0000000000 --- a/autogen/interop/helpers.py +++ /dev/null @@ -1,55 +0,0 @@ -# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai -# -# SPDX-License-Identifier: Apache-2.0 -# - -import importlib -import inspect -import logging -import pkgutil -import sys -from typing import Any, Dict, List, Set, Type - -from .interoperable import Interoperable - -logger = logging.getLogger(__name__) - - -def import_submodules(package_name: str) -> List[str]: - package = importlib.import_module(package_name) - imported_modules: List[str] = [] - for loader, module_name, is_pkg in pkgutil.walk_packages(package.__path__, package.__name__ + "."): - try: - importlib.import_module(module_name) - - imported_modules.append(module_name) - except Exception as e: - logger.info(f"Error importing {module_name}, most likely perfectly fine: {e}") - - return imported_modules - - -def find_classes_implementing_protocol(imported_modules: List[str], protocol: Type[Any]) -> List[Type[Any]]: - implementing_classes: Set[Type[Any]] = set() - for module in imported_modules: - for _, obj in inspect.getmembers(sys.modules[module], inspect.isclass): - if issubclass(obj, protocol) and obj is not protocol: - implementing_classes.add(obj) - - return list(implementing_classes) - - -def get_all_interoperability_classes() -> Dict[str, Type[Interoperable]]: - imported_modules = import_submodules("autogen.interop") - classes = find_classes_implementing_protocol(imported_modules, Interoperable) - - # check that all classes finish with 'Interoperability' - for cls in classes: - if not cls.__name__.endswith("Interoperability"): - raise RuntimeError(f"Class {cls} does not end with 'Interoperability'") - - retval = { - cls.__name__.split("Interoperability")[0].lower(): cls for cls in classes if cls.__name__ != "Interoperability" - } - - return retval diff --git a/autogen/interop/interoperability.py b/autogen/interop/interoperability.py index 27df3cd9c7..243f759d07 100644 --- a/autogen/interop/interoperability.py +++ b/autogen/interop/interoperability.py @@ -4,8 +4,8 @@ from typing import Any, Dict, List, Type from ..tools import Tool -from .helpers import get_all_interoperability_classes from .interoperable import Interoperable +from .registry import InteroperableRegistry __all__ = ["Interoperable"] @@ -18,8 +18,6 @@ class Interoperability: for retrieving and registering interoperability classes. """ - _interoperability_classes: Dict[str, Type[Interoperable]] = get_all_interoperability_classes() - def __init__(self) -> None: """ Initializes an instance of the Interoperability class. @@ -27,7 +25,7 @@ def __init__(self) -> None: This constructor does not perform any specific actions as the class is primarily used for its class methods to manage interoperability classes. """ - pass + self.registry = InteroperableRegistry.get_instance() def convert_tool(self, *, tool: Any, type: str, **kwargs: Any) -> Tool: """ @@ -48,8 +46,7 @@ def convert_tool(self, *, tool: Any, type: str, **kwargs: Any) -> Tool: interop = interop_cls() return interop.convert_tool(tool, **kwargs) - @classmethod - def get_interoperability_class(cls, type: str) -> Type[Interoperable]: + def get_interoperability_class(self, type: str) -> Type[Interoperable]: """ Retrieves the interoperability class corresponding to the specified type. @@ -62,35 +59,20 @@ def get_interoperability_class(cls, type: str) -> Type[Interoperable]: Raises: ValueError: If no interoperability class is found for the provided type. """ - if type not in cls._interoperability_classes: - raise ValueError(f"Interoperability class {type} not found") - return cls._interoperability_classes[type] + supported_types = self.registry.get_supported_types() + if type not in supported_types: + supported_types_formated = ", ".join(["'t'" for t in supported_types]) + raise ValueError( + f"Interoperability class {type} is not supported, supported types: {supported_types_formated}" + ) + + return self.registry.get_class(type) - @classmethod - def supported_types(cls) -> List[str]: + def get_supported_types(self) -> List[str]: """ Returns a sorted list of all supported interoperability types. Returns: List[str]: A sorted list of strings representing the supported interoperability types. """ - return sorted(cls._interoperability_classes.keys()) - - @classmethod - def register_interoperability_class(cls, name: str, interoperability_class: Type[Interoperable]) -> None: - """ - Registers a new interoperability class with the given name. - - Args: - name (str): The name to associate with the interoperability class. - interoperability_class (Type[Interoperable]): The class implementing the Interoperable protocol. - - Raises: - ValueError: If the provided class does not implement the Interoperable protocol. - """ - if not issubclass(interoperability_class, Interoperable): - raise ValueError( - f"Expected a class implementing `Interoperable` protocol, got {type(interoperability_class)}" - ) - - cls._interoperability_classes[name] = interoperability_class + return sorted(self.registry.get_supported_types()) diff --git a/autogen/interop/interoperable.py b/autogen/interop/interoperable.py index 75aefaaf25..2a11ace35d 100644 --- a/autogen/interop/interoperable.py +++ b/autogen/interop/interoperable.py @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: Apache-2.0 -from typing import Any, Protocol, runtime_checkable +from typing import Any, Optional, Protocol, runtime_checkable from ..tools import Tool @@ -32,3 +32,14 @@ def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: Tool: The converted tool in the desired format or type. """ ... + + @classmethod + def get_unsupported_reason(cls) -> Optional[str]: + """Returns the reason for the tool being unsupported. + + This method should be implemented by any class adhering to the `Interoperable` protocol. + + Returns: + str: The reason for the interoperability class being unsupported. + """ + ... diff --git a/autogen/interop/langchain/__init__.py b/autogen/interop/langchain/__init__.py index 233c8642c3..9af4e592cc 100644 --- a/autogen/interop/langchain/__init__.py +++ b/autogen/interop/langchain/__init__.py @@ -2,18 +2,6 @@ # # SPDX-License-Identifier: Apache-2.0 -import sys - -if sys.version_info < (3, 9): - raise ImportError("This submodule is only supported for Python versions 3.9 and above") - -try: - import langchain.tools -except ImportError: - raise ImportError( - "Please install `interop-langchain` extra to use this module:\n\n\tpip install ag2[interop-langchain]" - ) - from .langchain import LangchainInteroperability __all__ = ["LangchainInteroperability"] diff --git a/autogen/interop/langchain/langchain.py b/autogen/interop/langchain/langchain.py index 5c94569187..77850f8151 100644 --- a/autogen/interop/langchain/langchain.py +++ b/autogen/interop/langchain/langchain.py @@ -2,16 +2,17 @@ # # SPDX-License-Identifier: Apache-2.0 -from typing import Any - -from langchain_core.tools import BaseTool as LangchainTool +import sys +from typing import Any, Optional from ...tools import Tool from ..interoperable import Interoperable +from ..registry import register_interoperable_class __all__ = ["LangchainInteroperability"] +@register_interoperable_class("langchain") class LangchainInteroperability(Interoperable): """ A class implementing the `Interoperable` protocol for converting Langchain tools @@ -41,6 +42,8 @@ def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: ValueError: If the provided tool is not an instance of `LangchainTool`, or if any additional arguments are passed. """ + from langchain_core.tools import BaseTool as LangchainTool + if not isinstance(tool, LangchainTool): raise ValueError(f"Expected an instance of `langchain_core.tools.BaseTool`, got {type(tool)}") if kwargs: @@ -57,3 +60,17 @@ def func(tool_input: langchain_tool.args_schema) -> Any: # type: ignore[name-de description=langchain_tool.description, func=func, ) + + @classmethod + def get_unsupported_reason(cls) -> Optional[str]: + if sys.version_info < (3, 9): + return "This submodule is only supported for Python versions 3.9 and above" + + try: + import langchain_core.tools + except ImportError: + return ( + "Please install `interop-langchain` extra to use this module:\n\n\tpip install ag2[interop-langchain]" + ) + + return None diff --git a/autogen/interop/pydantic_ai/__init__.py b/autogen/interop/pydantic_ai/__init__.py index 55d52347ce..c022ebc414 100644 --- a/autogen/interop/pydantic_ai/__init__.py +++ b/autogen/interop/pydantic_ai/__init__.py @@ -2,18 +2,6 @@ # # SPDX-License-Identifier: Apache-2.0 -import sys - -if sys.version_info < (3, 9): - raise ImportError("This submodule is only supported for Python versions 3.9 and above") - -try: - import pydantic_ai.tools -except ImportError: - raise ImportError( - "Please install `interop-pydantic-ai` extra to use this module:\n\n\tpip install ag2[interop-pydantic-ai]" - ) - from .pydantic_ai import PydanticAIInteroperability __all__ = ["PydanticAIInteroperability"] diff --git a/autogen/interop/pydantic_ai/pydantic_ai.py b/autogen/interop/pydantic_ai/pydantic_ai.py index b76612d3c8..1d764d90b3 100644 --- a/autogen/interop/pydantic_ai/pydantic_ai.py +++ b/autogen/interop/pydantic_ai/pydantic_ai.py @@ -3,20 +3,20 @@ # SPDX-License-Identifier: Apache-2.0 +import sys import warnings from functools import wraps from inspect import signature from typing import Any, Callable, Optional -from pydantic_ai import RunContext -from pydantic_ai.tools import Tool as PydanticAITool - from ...tools import PydanticAITool as AG2PydanticAITool from ..interoperability import Interoperable +from ..registry import register_interoperable_class __all__ = ["PydanticAIInteroperability"] +@register_interoperable_class("pydanticai") class PydanticAIInteroperability(Interoperable): """ A class implementing the `Interoperable` protocol for converting Pydantic AI tools @@ -28,10 +28,9 @@ class PydanticAIInteroperability(Interoperable): into the tool's function. """ - @staticmethod def inject_params( - ctx: Optional[RunContext[Any]], - tool: PydanticAITool[Any], + ctx: Any, + tool: Any, ) -> Callable[..., Any]: """ Wraps the tool's function to inject context parameters and handle retries. @@ -49,30 +48,36 @@ def inject_params( Raises: ValueError: If the tool fails after the maximum number of retries. """ - max_retries = tool.max_retries if tool.max_retries is not None else 1 - f = tool.function + from pydantic_ai import RunContext + from pydantic_ai.tools import Tool as PydanticAITool + + ctx_typed: Optional[RunContext[Any]] = ctx + tool_typed: PydanticAITool[Any] = tool + + max_retries = tool_typed.max_retries if tool_typed.max_retries is not None else 1 + f = tool_typed.function @wraps(f) def wrapper(*args: Any, **kwargs: Any) -> Any: - if tool.current_retry >= max_retries: - raise ValueError(f"{tool.name} failed after {max_retries} retries") + if tool_typed.current_retry >= max_retries: + raise ValueError(f"{tool_typed.name} failed after {max_retries} retries") try: - if ctx is not None: + if ctx_typed is not None: kwargs.pop("ctx", None) - ctx.retry = tool.current_retry - result = f(**kwargs, ctx=ctx) # type: ignore[call-arg] + ctx_typed.retry = tool_typed.current_retry + result = f(**kwargs, ctx=ctx_typed) # type: ignore[call-arg] else: result = f(**kwargs) # type: ignore[call-arg] - tool.current_retry = 0 + tool_typed.current_retry = 0 except Exception as e: - tool.current_retry += 1 + tool_typed.current_retry += 1 raise e return result sig = signature(f) - if ctx is not None: + if ctx_typed is not None: new_params = [param for name, param in sig.parameters.items() if name != "ctx"] else: new_params = list(sig.parameters.values()) @@ -102,6 +107,9 @@ def convert_tool(self, tool: Any, deps: Any = None, **kwargs: Any) -> AG2Pydanti dependencies are missing for tools that require a context. UserWarning: If the `deps` argument is provided for a tool that does not take a context. """ + from pydantic_ai import RunContext + from pydantic_ai.tools import Tool as PydanticAITool + if not isinstance(tool, PydanticAITool): raise ValueError(f"Expected an instance of `pydantic_ai.tools.Tool`, got {type(tool)}") @@ -139,3 +147,15 @@ def convert_tool(self, tool: Any, deps: Any = None, **kwargs: Any) -> AG2Pydanti func=func, parameters_json_schema=pydantic_ai_tool._parameters_json_schema, ) + + @classmethod + def get_unsupported_reason(cls) -> Optional[str]: + if sys.version_info < (3, 9): + return "This submodule is only supported for Python versions 3.9 and above" + + try: + import pydantic_ai.tools + except ImportError: + return "Please install `interop-pydantic-ai` extra to use this module:\n\n\tpip install ag2[interop-pydantic-ai]" + + return None diff --git a/autogen/interop/registry.py b/autogen/interop/registry.py index 949182eeaa..443dcb5beb 100644 --- a/autogen/interop/registry.py +++ b/autogen/interop/registry.py @@ -6,12 +6,12 @@ from .interoperable import Interoperable -__all__ = ["register_interoperable_class"] +__all__ = ["register_interoperable_class", "InteroperableRegistry"] InteroperableClass = TypeVar("InteroperableClass", bound=Type[Interoperable]) -class _InteroperableRegistry: +class InteroperableRegistry: def __init__(self) -> None: self._registry: Dict[str, Type[Interoperable]] = {} @@ -26,16 +26,21 @@ def register(self, short_name: str, cls: InteroperableClass) -> InteroperableCla def get_short_names(self) -> List[str]: return sorted(self._registry.keys()) + def get_supported_types(self) -> List[str]: + short_names = self.get_short_names() + supported_types = [name for name in short_names if self._registry[name].get_unsupported_reason() is None] + return supported_types + def get_class(self, short_name: str) -> Type[Interoperable]: return self._registry[short_name] @classmethod - def get_instance(cls) -> "_InteroperableRegistry": + def get_instance(cls) -> "InteroperableRegistry": return _register # global registry -_register = _InteroperableRegistry() +_register = InteroperableRegistry() # register decorator diff --git a/test/interop/crewai/test_crewai.py b/test/interop/crewai/test_crewai.py index 1a2cbbd513..00666740fe 100644 --- a/test/interop/crewai/test_crewai.py +++ b/test/interop/crewai/test_crewai.py @@ -93,3 +93,19 @@ def test_with_llm(self) -> None: return assert False, "Tool response not found in chat messages" + + def test_get_unsupported_reason(self) -> None: + crewai_interop = CrewAIInteroperability() + assert crewai_interop.get_unsupported_reason() is None + + +@pytest.mark.skipif( + sys.version_info >= (3, 10) or sys.version_info < (3, 13), reason="Crew AI Interoperability is supported" +) +class TestCrewAIInteroperabilityIfNotSupported: + def test_get_unsupported_reason(self) -> None: + crewai_interop = CrewAIInteroperability() + assert ( + crewai_interop.get_unsupported_reason() + == "This submodule is only supported for Python versions 3.10, 3.11, and 3.12" + ) diff --git a/test/interop/test_helpers.py b/test/interop/test_helpers.py deleted file mode 100644 index 76f52a85f4..0000000000 --- a/test/interop/test_helpers.py +++ /dev/null @@ -1,69 +0,0 @@ -# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai -# -# SPDX-License-Identifier: Apache-2.0 - -import sys - -import pytest - -from autogen.interop import Interoperability, Interoperable -from autogen.interop.helpers import ( - find_classes_implementing_protocol, - get_all_interoperability_classes, - import_submodules, -) - - -class TestHelpers: - @pytest.fixture(autouse=True) - def setup_method(self) -> None: - self.imported_modules = import_submodules("autogen.interop") - - def test_import_submodules(self) -> None: - assert "autogen.interop.helpers" in self.imported_modules - - def test_find_classes_implementing_protocol(self) -> None: - actual = find_classes_implementing_protocol(self.imported_modules, Interoperable) - print(f"test_find_classes_implementing_protocol: {actual=}") - - assert Interoperability in actual - expected_count = 1 - - if sys.version_info >= (3, 10) and sys.version_info < (3, 13): - from autogen.interop.crewai import CrewAIInteroperability - - assert CrewAIInteroperability in actual - expected_count += 1 - - if sys.version_info >= (3, 9): - from autogen.interop.langchain import LangchainInteroperability - from autogen.interop.pydantic_ai import PydanticAIInteroperability - - assert LangchainInteroperability in actual - assert PydanticAIInteroperability in actual - expected_count += 2 - - assert len(actual) == expected_count - - def test_get_all_interoperability_classes(self) -> None: - - actual = get_all_interoperability_classes() - - if sys.version_info < (3, 9): - assert actual == {} - - if sys.version_info >= (3, 10) and sys.version_info < (3, 13): - from autogen.interop.crewai import CrewAIInteroperability - from autogen.interop.langchain import LangchainInteroperability - from autogen.interop.pydantic_ai import PydanticAIInteroperability - - assert actual == { - "pydanticai": PydanticAIInteroperability, - "crewai": CrewAIInteroperability, - "langchain": LangchainInteroperability, - } - - if (sys.version_info >= (3, 9) and sys.version_info < (3, 10)) and sys.version_info >= (3, 13): - from autogen.interop.langchain import LangchainInteroperability - - assert actual == {"langchain": LangchainInteroperability} diff --git a/test/interop/test_interoperability.py b/test/interop/test_interoperability.py index df7789dd13..2b1e0704ab 100644 --- a/test/interop/test_interoperability.py +++ b/test/interop/test_interoperability.py @@ -8,13 +8,12 @@ import pytest -from autogen.interop import Interoperability, Interoperable -from autogen.tools.tool import Tool +from autogen.interop import Interoperability class TestInteroperability: def test_supported_types(self) -> None: - actual = Interoperability.supported_types() + actual = Interoperability().get_supported_types() if sys.version_info < (3, 9): assert actual == [] @@ -28,26 +27,6 @@ def test_supported_types(self) -> None: if sys.version_info >= (3, 13): assert actual == ["langchain", "pydanticai"] - def test_register_interoperability_class(self) -> None: - org_interoperability_classes = Interoperability._interoperability_classes - try: - - class MyInteroperability: - def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: - return Tool(name="test", description="test description", func=tool) - - Interoperability.register_interoperability_class("my_interop", MyInteroperability) - assert Interoperability.get_interoperability_class("my_interop") == MyInteroperability - - interop = Interoperability() - tool = interop.convert_tool(type="my_interop", tool=lambda x: x) - assert tool.name == "test" - assert tool.description == "test description" - assert tool.func("hello") == "hello" - - finally: - Interoperability._interoperability_classes = org_interoperability_classes - @pytest.mark.skipif( sys.version_info < (3, 10) or sys.version_info >= (3, 13), reason="Only Python 3.10, 3.11, 3.12 are supported" ) From 07110727d9cf23a18d01db277e0f36dee1337b65 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Thu, 19 Dec 2024 14:30:04 +0100 Subject: [PATCH 57/70] WIP interoperability blog --- .../index.mdx | 139 ++++++++++++++++++ website/blog/authors.yml | 6 + 2 files changed, 145 insertions(+) create mode 100644 website/blog/2024-12-18-Tools-interoperability/index.mdx diff --git a/website/blog/2024-12-18-Tools-interoperability/index.mdx b/website/blog/2024-12-18-Tools-interoperability/index.mdx new file mode 100644 index 0000000000..605141aab6 --- /dev/null +++ b/website/blog/2024-12-18-Tools-interoperability/index.mdx @@ -0,0 +1,139 @@ +--- +title: Cross-Framework LLM Tool Integration with AG2 +authors: + - rjambrecic +tags: [LLM, tools, langchain, crewai, pydanticai] +--- + +**TL;DR** +AG2 lets you integrate tools from different frameworks like **LangChain**, **CrewAI** and **PydanticAI**. + +- **LangChain**: Quickly bring in tools for tasks like API querying and web scraping. +- **CrewAI**: Use a wide variety of tools for web scraping, search, and more. +- **PydanticAI**: Leverage dependency injection for context-driven tools and structured data processing. +This integration allows you to combine and use tools from multiple frameworks within AG2, expanding your agents' capabilities. + +In this post, we will demonstrate how to integrate LLM tools from various frameworks—including [LangChain Tools](https://python.langchain.com/v0.1/docs/modules/tools), +[CrewAI Tools](https://github.com/crewAIInc/crewAI-tools/tree/main) and [PydanticAI Tools](https://ai.pydantic.dev/tools/) into the AG2 framework. +This process enables smooth interoperability between these systems, allowing developers to leverage the unique capabilities of each toolset within AG2's flexible agent-based architecture. +By the end of this post, you will understand how to configure agents, adapt these tools for use in AG2, and validate the integration through practical examples. + +## LangChain Tools Integration + +LangChain is a popular framework that offers a wide range of tools to work with LLMs. LangChain has already implemented a variety of tools that can be easily integrated into AG2. You can explore the available tools in the [LangChain Community Tools](https://github.com/langchain-ai/langchain/tree/master/libs/community/langchain_community/tools) folder. These tools, such as those for querying APIs, web scraping, and text generation, can be quickly incorporated into AG2, providing powerful functionality for your agents. + +### Installation +To integrate LangChain tools into the AG2 framework, install the required dependencies: + +```bash +pip install ag2[interop-langchain] +``` + +Additionally, this notebook uses LangChain's [Wikipedia Tool](https://api.python.langchain.com/en/latest/tools/langchain_community.tools.wikipedia.tool.WikipediaQueryRun.html), which requires the `wikipedia` package. Install it with: + +```bash +pip install wikipedia +``` + +### Imports + +Import necessary modules and tools. +- `WikipediaQueryRun` and `WikipediaAPIWrapper`: Tools for querying Wikipedia. +- `AssistantAgent` and `UserProxyAgent`: Agents that facilitate communication in the AG2 framework. +- `Interoperability`: This module acts as a bridge, making it easier to integrate LangChain tools with AG2’s architecture. + +```python +import os + +from langchain_community.tools import WikipediaQueryRun +from langchain_community.utilities import WikipediaAPIWrapper + +from autogen import AssistantAgent, UserProxyAgent +from autogen.interop import Interoperability +``` + +### Agent Configuration + +Configure the agents for the interaction. +- `config_list` defines the LLM configurations, including the model and API key. +- `UserProxyAgent` simulates user inputs without requiring actual human interaction (set to `NEVER`). +- `AssistantAgent` represents the AI agent, configured with the LLM settings. + +```python +config_list = [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}] +user_proxy = UserProxyAgent( + name="User", + human_input_mode="NEVER", +) + +chatbot = AssistantAgent( + name="chatbot", + llm_config={"config_list": config_list}, +) +``` + +### Tool Integration + +- Initialize and register the LangChain tool with AG2. +- `WikipediaAPIWrapper`: Configured to fetch the top 1 result from Wikipedia with a maximum of 1000 characters per document. +- `WikipediaQueryRun`: A LangChain tool that executes Wikipedia queries. +- `LangchainInteroperability`: Converts the LangChain tool into a format compatible with the AG2 framework. +- `ag2_tool.register_for_execution(user_proxy)`: Registers the tool for use by the user_proxy agent. +- `ag2_tool.register_for_llm(chatbot)`: Registers the tool for integration with the chatbot agent. + +```python +api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=1000) +langchain_tool = WikipediaQueryRun(api_wrapper=api_wrapper) + +interop = Interoperability() +ag2_tool = interop.convert_tool(tool=langchain_tool, type="langchain") + +ag2_tool.register_for_execution(user_proxy) +ag2_tool.register_for_llm(chatbot) +``` + +### Initiate Chat +```python +message = "Tell me about the history of the United States" +user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2) +``` + +```console +User (to chatbot): + +Tell me about the history of the United States + +-------------------------------------------------------------------------------- +chatbot (to User): + +***** Suggested tool call (call_hhy2G43ymytUFmJlDsK9J0tk): wikipedia ***** +Arguments: +{"tool_input":{"query":"history of the United States"}} +************************************************************************** + +-------------------------------------------------------------------------------- + +>>>>>>>> EXECUTING FUNCTION wikipedia... +User (to chatbot): + +***** Response from calling tool (call_hhy2G43ymytUFmJlDsK9J0tk) ***** +Page: History of the United States +Summary: The history of the lands that became the United States began with the arrival of the first people in the Americas around 15,000 BC. After European colonization of North America began in the late 15th century, wars and epidemics decimated Indigenous societies. By the 1760s, the thirteen British colonies were established. The Southern Colonies built an agricultural system on slave labor, enslaving millions from Africa. After defeating France, the British Parliament imposed a series of taxes; resistance to these taxes, especially the Boston Tea Party in 1773, led to Parliament issuing the Intolerable Acts designed to end self-government. +In 1776, the United States declared its independence. Led by General George Washington, it won the Revolutionary War in 1783. The Constitution was adopted in 1789, and a Bill of Rights was added in 1791 to guarantee inalienable rights. Washington, the first president, and his adviser Alexander Hamilton created a +********************************************************************** + +-------------------------------------------------------------------------------- +chatbot (to User): + +The history of the United States begins with the arrival of the first peoples in the Americas around 15,000 BC. This pre-Columbian era was followed by European colonization, beginning in the late 15th century, which dramatically altered the indigenous societies through wars and epidemics. + +By the 1760s, thirteen British colonies were established along the Atlantic seaboard. In the Southern Colonies, an agricultural economy heavily reliant on enslaved labor from Africa was developed. The British victory over France in the Seven Years' War led Parliament to impose various taxes on the colonies. Resistance to these taxes, exemplified by the Boston Tea Party in 1773, prompted the Parliament to enact the Intolerable Acts, seeking to curtail colonial self-governance. + +The United States declared independence in 1776. Under the leadership of General George Washington, the American Revolutionary War concluded successfully in 1783. Subsequently, the U.S. Constitution was adopted in 1789, with the Bill of Rights added in 1791 to ensure inalienable rights. During this early period, President George Washington and his advisor Alexander Hamilton played significant roles in forming the young nation's governmental and economic foundations. + +This overview covers the early formation and foundational moments of what became the United States, setting the stage for the country's subsequent expansion and development. TERMINATE + +-------------------------------------------------------------------------------- +``` + + diff --git a/website/blog/authors.yml b/website/blog/authors.yml index f93f3aee16..f689a1dfd6 100644 --- a/website/blog/authors.yml +++ b/website/blog/authors.yml @@ -188,3 +188,9 @@ AgentGenie: title: AG2 Contributor url: https://github.com/AgentGenie image_url: https://github.com/AgentGenie.png + +rjambrecic: + name: Robert Jambrecic + title: Machine Learning Engineer at Airt + url: https://github.com/rjambrecic + image_url: https://github.com/rjambrecic.png From 94c2378fd11326306e101ca191804e155af6b164 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 19 Dec 2024 14:46:09 +0100 Subject: [PATCH 58/70] type fixing Signed-off-by: Davor Runje --- autogen/interop/langchain/langchain.py | 4 ++-- autogen/interop/pydantic_ai/pydantic_ai.py | 6 +++--- autogen/tools/tool.py | 5 ----- pyproject.toml | 3 ++- 4 files changed, 7 insertions(+), 11 deletions(-) diff --git a/autogen/interop/langchain/langchain.py b/autogen/interop/langchain/langchain.py index 77850f8151..841689e283 100644 --- a/autogen/interop/langchain/langchain.py +++ b/autogen/interop/langchain/langchain.py @@ -50,9 +50,9 @@ def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: raise ValueError(f"The LangchainInteroperability does not support any additional arguments, got {kwargs}") # needed for type checking - langchain_tool: LangchainTool = tool + langchain_tool: LangchainTool = tool # type: ignore - def func(tool_input: langchain_tool.args_schema) -> Any: # type: ignore[name-defined] + def func(tool_input: langchain_tool.args_schema) -> Any: # type: ignore return langchain_tool.run(tool_input.model_dump()) return Tool( diff --git a/autogen/interop/pydantic_ai/pydantic_ai.py b/autogen/interop/pydantic_ai/pydantic_ai.py index 1d764d90b3..d3260b4e82 100644 --- a/autogen/interop/pydantic_ai/pydantic_ai.py +++ b/autogen/interop/pydantic_ai/pydantic_ai.py @@ -51,8 +51,8 @@ def inject_params( from pydantic_ai import RunContext from pydantic_ai.tools import Tool as PydanticAITool - ctx_typed: Optional[RunContext[Any]] = ctx - tool_typed: PydanticAITool[Any] = tool + ctx_typed: Optional[RunContext[Any]] = ctx # type: ignore + tool_typed: PydanticAITool[Any] = tool # type: ignore max_retries = tool_typed.max_retries if tool_typed.max_retries is not None else 1 f = tool_typed.function @@ -114,7 +114,7 @@ def convert_tool(self, tool: Any, deps: Any = None, **kwargs: Any) -> AG2Pydanti raise ValueError(f"Expected an instance of `pydantic_ai.tools.Tool`, got {type(tool)}") # needed for type checking - pydantic_ai_tool: PydanticAITool[Any] = tool + pydantic_ai_tool: PydanticAITool[Any] = tool # type: ignore[no-any-unimported] if tool.takes_ctx and deps is None: raise ValueError("If the tool takes a context, the `deps` argument must be provided") diff --git a/autogen/tools/tool.py b/autogen/tools/tool.py index c0e615f37c..6e41238287 100644 --- a/autogen/tools/tool.py +++ b/autogen/tools/tool.py @@ -7,11 +7,6 @@ from autogen.agentchat.conversable_agent import ConversableAgent -try: - from crewai.tools import BaseTool as CrewAITool -except ImportError: - CrewAITool = MagicMock() - __all__ = ["Tool"] diff --git a/pyproject.toml b/pyproject.toml index 74a6d04c1e..c209c0b2fe 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -92,7 +92,8 @@ no_implicit_optional = true check_untyped_defs = true warn_return_any = true show_error_codes = true -warn_unused_ignores = true + +warn_unused_ignores = false disallow_incomplete_defs = true disallow_untyped_decorators = true From 2de4a90cb70705f6c65ab79d6f516640225fe776 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 19 Dec 2024 15:13:07 +0100 Subject: [PATCH 59/70] refactoring: making convert_tool a class method --- autogen/interop/__init__.py | 2 +- autogen/interop/crewai/crewai.py | 5 +-- autogen/interop/interoperability.py | 27 +++++++---------- autogen/interop/interoperable.py | 3 +- autogen/interop/langchain/__init__.py | 4 +-- autogen/interop/langchain/langchain.py | 7 +++-- autogen/interop/pydantic_ai/pydantic_ai.py | 4 ++- test/interop/crewai/test_crewai.py | 15 +++------ test/interop/langchain/test_langchain.py | 32 ++++++++++++-------- test/interop/pydantic_ai/test_pydantic_ai.py | 22 ++++++++------ test/interop/test_interoperability.py | 5 ++- 11 files changed, 66 insertions(+), 60 deletions(-) diff --git a/autogen/interop/__init__.py b/autogen/interop/__init__.py index 3afb5a529f..8f070c8f24 100644 --- a/autogen/interop/__init__.py +++ b/autogen/interop/__init__.py @@ -5,7 +5,7 @@ from .crewai import CrewAIInteroperability from .interoperability import Interoperability from .interoperable import Interoperable -from .langchain import LangchainInteroperability +from .langchain import LangChainInteroperability from .pydantic_ai import PydanticAIInteroperability from .registry import register_interoperable_class diff --git a/autogen/interop/crewai/crewai.py b/autogen/interop/crewai/crewai.py index 43465fa875..d6f2a608ba 100644 --- a/autogen/interop/crewai/crewai.py +++ b/autogen/interop/crewai/crewai.py @@ -4,7 +4,7 @@ import re import sys -from typing import Any, Optional, cast +from typing import Any, Optional from ...tools import Tool from ..interoperable import Interoperable @@ -26,7 +26,8 @@ class CrewAIInteroperability(Interoperable): This class takes a `CrewAITool` and converts it into a standard `Tool` object. """ - def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: + @classmethod + def convert_tool(cls, tool: Any, **kwargs: Any) -> Tool: """ Converts a given CrewAI tool into a general `Tool` format. diff --git a/autogen/interop/interoperability.py b/autogen/interop/interoperability.py index 243f759d07..b86285d6a6 100644 --- a/autogen/interop/interoperability.py +++ b/autogen/interop/interoperability.py @@ -18,16 +18,10 @@ class Interoperability: for retrieving and registering interoperability classes. """ - def __init__(self) -> None: - """ - Initializes an instance of the Interoperability class. - - This constructor does not perform any specific actions as the class is primarily used for its class - methods to manage interoperability classes. - """ - self.registry = InteroperableRegistry.get_instance() + registry = InteroperableRegistry.get_instance() - def convert_tool(self, *, tool: Any, type: str, **kwargs: Any) -> Tool: + @classmethod + def convert_tool(cls, *, tool: Any, type: str, **kwargs: Any) -> Tool: """ Converts a given tool to an instance of a specified interoperability type. @@ -42,11 +36,11 @@ def convert_tool(self, *, tool: Any, type: str, **kwargs: Any) -> Tool: Raises: ValueError: If the interoperability class for the provided type is not found. """ - interop_cls = self.get_interoperability_class(type) - interop = interop_cls() + interop = cls.get_interoperability_class(type) return interop.convert_tool(tool, **kwargs) - def get_interoperability_class(self, type: str) -> Type[Interoperable]: + @classmethod + def get_interoperability_class(cls, type: str) -> Type[Interoperable]: """ Retrieves the interoperability class corresponding to the specified type. @@ -59,20 +53,21 @@ def get_interoperability_class(self, type: str) -> Type[Interoperable]: Raises: ValueError: If no interoperability class is found for the provided type. """ - supported_types = self.registry.get_supported_types() + supported_types = cls.registry.get_supported_types() if type not in supported_types: supported_types_formated = ", ".join(["'t'" for t in supported_types]) raise ValueError( f"Interoperability class {type} is not supported, supported types: {supported_types_formated}" ) - return self.registry.get_class(type) + return cls.registry.get_class(type) - def get_supported_types(self) -> List[str]: + @classmethod + def get_supported_types(cls) -> List[str]: """ Returns a sorted list of all supported interoperability types. Returns: List[str]: A sorted list of strings representing the supported interoperability types. """ - return sorted(self.registry.get_supported_types()) + return sorted(cls.registry.get_supported_types()) diff --git a/autogen/interop/interoperable.py b/autogen/interop/interoperable.py index 2a11ace35d..185e36089d 100644 --- a/autogen/interop/interoperable.py +++ b/autogen/interop/interoperable.py @@ -18,7 +18,8 @@ class Interoperable(Protocol): `convert_tool` to convert a given tool into a desired format or type. """ - def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: + @classmethod + def convert_tool(cls, tool: Any, **kwargs: Any) -> Tool: """ Converts a given tool to a desired format or type. diff --git a/autogen/interop/langchain/__init__.py b/autogen/interop/langchain/__init__.py index 9af4e592cc..1aa1f7892c 100644 --- a/autogen/interop/langchain/__init__.py +++ b/autogen/interop/langchain/__init__.py @@ -2,6 +2,6 @@ # # SPDX-License-Identifier: Apache-2.0 -from .langchain import LangchainInteroperability +from .langchain import LangChainInteroperability -__all__ = ["LangchainInteroperability"] +__all__ = ["LangChainInteroperability"] diff --git a/autogen/interop/langchain/langchain.py b/autogen/interop/langchain/langchain.py index 841689e283..446617f7e2 100644 --- a/autogen/interop/langchain/langchain.py +++ b/autogen/interop/langchain/langchain.py @@ -9,11 +9,11 @@ from ..interoperable import Interoperable from ..registry import register_interoperable_class -__all__ = ["LangchainInteroperability"] +__all__ = ["LangChainInteroperability"] @register_interoperable_class("langchain") -class LangchainInteroperability(Interoperable): +class LangChainInteroperability(Interoperable): """ A class implementing the `Interoperable` protocol for converting Langchain tools into a general `Tool` format. @@ -23,7 +23,8 @@ class LangchainInteroperability(Interoperable): the `Tool` format. """ - def convert_tool(self, tool: Any, **kwargs: Any) -> Tool: + @classmethod + def convert_tool(cls, tool: Any, **kwargs: Any) -> Tool: """ Converts a given Langchain tool into a general `Tool` format. diff --git a/autogen/interop/pydantic_ai/pydantic_ai.py b/autogen/interop/pydantic_ai/pydantic_ai.py index d3260b4e82..fbb12e35b5 100644 --- a/autogen/interop/pydantic_ai/pydantic_ai.py +++ b/autogen/interop/pydantic_ai/pydantic_ai.py @@ -28,6 +28,7 @@ class PydanticAIInteroperability(Interoperable): into the tool's function. """ + @staticmethod def inject_params( ctx: Any, tool: Any, @@ -86,7 +87,8 @@ def wrapper(*args: Any, **kwargs: Any) -> Any: return wrapper - def convert_tool(self, tool: Any, deps: Any = None, **kwargs: Any) -> AG2PydanticAITool: + @classmethod + def convert_tool(cls, tool: Any, deps: Any = None, **kwargs: Any) -> AG2PydanticAITool: """ Converts a given Pydantic AI tool into a general `Tool` format. diff --git a/test/interop/crewai/test_crewai.py b/test/interop/crewai/test_crewai.py index 00666740fe..0d39926638 100644 --- a/test/interop/crewai/test_crewai.py +++ b/test/interop/crewai/test_crewai.py @@ -31,21 +31,18 @@ class TestCrewAIInteroperability: @pytest.fixture(autouse=True) def setup(self) -> None: - self.crewai_interop = CrewAIInteroperability() crewai_tool = FileReadTool() self.model_type = crewai_tool.args_schema - self.tool = self.crewai_interop.convert_tool(crewai_tool) + self.tool = CrewAIInteroperability.convert_tool(crewai_tool) def test_type_checks(self) -> None: # mypy should fail if the type checks are not correct - interop: Interoperable = self.crewai_interop + interop: Interoperable = CrewAIInteroperability() + # runtime check assert isinstance(interop, Interoperable) - def test_init(self) -> None: - assert isinstance(self.crewai_interop, Interoperable) - def test_convert_tool(self) -> None: with TemporaryDirectory() as tmp_dir: file_path = f"{tmp_dir}/test.txt" @@ -95,8 +92,7 @@ def test_with_llm(self) -> None: assert False, "Tool response not found in chat messages" def test_get_unsupported_reason(self) -> None: - crewai_interop = CrewAIInteroperability() - assert crewai_interop.get_unsupported_reason() is None + assert CrewAIInteroperability.get_unsupported_reason() is None @pytest.mark.skipif( @@ -104,8 +100,7 @@ def test_get_unsupported_reason(self) -> None: ) class TestCrewAIInteroperabilityIfNotSupported: def test_get_unsupported_reason(self) -> None: - crewai_interop = CrewAIInteroperability() assert ( - crewai_interop.get_unsupported_reason() + CrewAIInteroperability.get_unsupported_reason() == "This submodule is only supported for Python versions 3.10, 3.11, and 3.12" ) diff --git a/test/interop/langchain/test_langchain.py b/test/interop/langchain/test_langchain.py index 070c396784..376612ad11 100644 --- a/test/interop/langchain/test_langchain.py +++ b/test/interop/langchain/test_langchain.py @@ -16,17 +16,17 @@ if sys.version_info >= (3, 9): from langchain.tools import tool - from autogen.interop.langchain import LangchainInteroperability + from autogen.interop.langchain import LangChainInteroperability else: tool = unittest.mock.MagicMock() - LangchainInteroperability = unittest.mock.MagicMock() + LangChainInteroperability = unittest.mock.MagicMock() # skip if python version is not >= 3.9 @pytest.mark.skipif( sys.version_info < (3, 9), reason="Only Python 3.9 and above are supported for LangchainInteroperability" ) -class TestLangchainInteroperability: +class TestLangChainInteroperability: @pytest.fixture(autouse=True) def setup(self) -> None: class SearchInput(BaseModel): @@ -37,19 +37,16 @@ def search(query: SearchInput) -> str: """Look up things online.""" return "LangChain Integration" - self.langchain_interop = LangchainInteroperability() self.model_type = search.args_schema - self.tool = self.langchain_interop.convert_tool(search) + self.tool = LangChainInteroperability.convert_tool(search) def test_type_checks(self) -> None: # mypy should fail if the type checks are not correct - interop: Interoperable = self.langchain_interop + interop: Interoperable = LangChainInteroperability() + # runtime check assert isinstance(interop, Interoperable) - def test_init(self) -> None: - assert isinstance(self.langchain_interop, Interoperable) - def test_convert_tool(self) -> None: assert self.tool.name == "search-tool" assert self.tool.description == "Look up things online." @@ -82,12 +79,15 @@ def test_with_llm(self) -> None: assert False, "No tool response found in chat messages" + def test_get_unsupported_reason(self) -> None: + assert LangChainInteroperability.get_unsupported_reason() is None + # skip if python version is not >= 3.9 @pytest.mark.skipif( sys.version_info < (3, 9), reason="Only Python 3.9 and above are supported for LangchainInteroperability" ) -class TestLangchainInteroperabilityWithoutPydanticInput: +class TestLangChainInteroperabilityWithoutPydanticInput: @pytest.fixture(autouse=True) def setup(self) -> None: @tool @@ -95,8 +95,7 @@ def search(query: str, max_length: int) -> str: """Look up things online.""" return f"LangChain Integration, max_length: {max_length}" - self.langchain_interop = LangchainInteroperability() - self.tool = self.langchain_interop.convert_tool(search) + self.tool = LangChainInteroperability.convert_tool(search) self.model_type = search.args_schema def test_convert_tool(self) -> None: @@ -130,3 +129,12 @@ def test_with_llm(self) -> None: return assert False, "No tool response found in chat messages" + + +@pytest.mark.skipif(sys.version_info >= (3, 9), reason="LangChain Interoperability is supported") +class TestLangChainInteroperabilityIfNotSupported: + def test_get_unsupported_reason(self) -> None: + assert ( + LangChainInteroperability.get_unsupported_reason() + == "This submodule is only supported for Python versions 3.9 and above" + ) diff --git a/test/interop/pydantic_ai/test_pydantic_ai.py b/test/interop/pydantic_ai/test_pydantic_ai.py index 6b5dae9590..764a44e855 100644 --- a/test/interop/pydantic_ai/test_pydantic_ai.py +++ b/test/interop/pydantic_ai/test_pydantic_ai.py @@ -38,19 +38,15 @@ def roll_dice() -> str: """Roll a six-sided dice and return the result.""" return str(random.randint(1, 6)) - self.pydantic_ai_interop = PydanticAIInteroperability() pydantic_ai_tool = PydanticAITool(roll_dice, max_retries=3) - self.tool = self.pydantic_ai_interop.convert_tool(pydantic_ai_tool) + self.tool = PydanticAIInteroperability.convert_tool(pydantic_ai_tool) def test_type_checks(self) -> None: # mypy should fail if the type checks are not correct - interop: Interoperable = self.pydantic_ai_interop + interop: Interoperable = PydanticAIInteroperability() # runtime check assert isinstance(interop, Interoperable) - def test_init(self) -> None: - assert isinstance(self.pydantic_ai_interop, Interoperable) - def test_convert_tool(self) -> None: assert self.tool.name == "roll_dice" assert self.tool.description == "Roll a six-sided dice and return the result." @@ -162,14 +158,13 @@ def get_player(ctx: RunContext[Player], additional_info: Optional[str] = None) - """ return f"Name: {ctx.deps.name}, Age: {ctx.deps.age}, Additional info: {additional_info}" # type: ignore[attr-defined] - self.pydantic_ai_interop = PydanticAIInteroperability() self.pydantic_ai_tool = PydanticAITool(get_player, takes_ctx=True) player = Player(name="Luka", age=25) - self.tool = self.pydantic_ai_interop.convert_tool(tool=self.pydantic_ai_tool, deps=player) + self.tool = PydanticAIInteroperability.convert_tool(tool=self.pydantic_ai_tool, deps=player) def test_convert_tool_raises_error_if_take_ctx_is_true_and_deps_is_none(self) -> None: with pytest.raises(ValueError, match="If the tool takes a context, the `deps` argument must be provided"): - self.pydantic_ai_interop.convert_tool(tool=self.pydantic_ai_tool, deps=None) + PydanticAIInteroperability.convert_tool(tool=self.pydantic_ai_tool, deps=None) def test_expected_tools(self) -> None: config_list = [{"model": "gpt-4o", "api_key": "abc"}] @@ -229,3 +224,12 @@ def test_with_llm(self) -> None: return assert False, "No tool response found in chat messages" + + +@pytest.mark.skipif(sys.version_info >= (3, 9), reason="LangChain Interoperability is supported") +class TestPydanticAIInteroperabilityIfNotSupported: + def test_get_unsupported_reason(self) -> None: + assert ( + PydanticAIInteroperability.get_unsupported_reason() + == "This submodule is only supported for Python versions 3.9 and above" + ) diff --git a/test/interop/test_interoperability.py b/test/interop/test_interoperability.py index 2b1e0704ab..3925f056f1 100644 --- a/test/interop/test_interoperability.py +++ b/test/interop/test_interoperability.py @@ -13,7 +13,7 @@ class TestInteroperability: def test_supported_types(self) -> None: - actual = Interoperability().get_supported_types() + actual = Interoperability.get_supported_types() if sys.version_info < (3, 9): assert actual == [] @@ -35,8 +35,7 @@ def test_crewai(self) -> None: crewai_tool = FileReadTool() - interoperability = Interoperability() - tool = interoperability.convert_tool(type="crewai", tool=crewai_tool) + tool = Interoperability.convert_tool(type="crewai", tool=crewai_tool) with TemporaryDirectory() as tmp_dir: file_path = f"{tmp_dir}/test.txt" From 9ce614fc87b5358726b2564e881dcbefac5e2630 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Thu, 19 Dec 2024 15:14:50 +0100 Subject: [PATCH 60/70] Refactoring and test_pydantic_ai_tool.py added --- autogen/interop/pydantic_ai/pydantic_ai.py | 2 +- .../pydantic_ai}/pydantic_ai_tool.py | 5 +- autogen/tools/__init__.py | 7 +- autogen/tools/tool.py | 10 +-- .../pydantic_ai/test_pydantic_ai_tool.py | 74 +++++++++++++++++++ 5 files changed, 84 insertions(+), 14 deletions(-) rename autogen/{tools => interop/pydantic_ai}/pydantic_ai_tool.py (96%) create mode 100644 test/interop/pydantic_ai/test_pydantic_ai_tool.py diff --git a/autogen/interop/pydantic_ai/pydantic_ai.py b/autogen/interop/pydantic_ai/pydantic_ai.py index b170ccf501..39d157daa6 100644 --- a/autogen/interop/pydantic_ai/pydantic_ai.py +++ b/autogen/interop/pydantic_ai/pydantic_ai.py @@ -11,8 +11,8 @@ from pydantic_ai import RunContext from pydantic_ai.tools import Tool as PydanticAITool -from ...tools import PydanticAITool as AG2PydanticAITool from ..interoperability import Interoperable +from .pydantic_ai_tool import PydanticAITool as AG2PydanticAITool __all__ = ["PydanticAIInteroperability"] diff --git a/autogen/tools/pydantic_ai_tool.py b/autogen/interop/pydantic_ai/pydantic_ai_tool.py similarity index 96% rename from autogen/tools/pydantic_ai_tool.py rename to autogen/interop/pydantic_ai/pydantic_ai_tool.py index a106cd4b70..629f65e7ad 100644 --- a/autogen/tools/pydantic_ai_tool.py +++ b/autogen/interop/pydantic_ai/pydantic_ai_tool.py @@ -4,9 +4,8 @@ from typing import Any, Callable, Dict -from autogen.agentchat.conversable_agent import ConversableAgent - -from .tool import Tool +from ...agentchat.conversable_agent import ConversableAgent +from ...tools import Tool __all__ = ["PydanticAITool"] diff --git a/autogen/tools/__init__.py b/autogen/tools/__init__.py index d787ae1a60..5902681ce0 100644 --- a/autogen/tools/__init__.py +++ b/autogen/tools/__init__.py @@ -1,4 +1,7 @@ -from .pydantic_ai_tool import PydanticAITool +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + from .tool import Tool -__all__ = ["PydanticAITool", "Tool"] +__all__ = ["Tool"] diff --git a/autogen/tools/tool.py b/autogen/tools/tool.py index c0e615f37c..43914aa59c 100644 --- a/autogen/tools/tool.py +++ b/autogen/tools/tool.py @@ -2,15 +2,9 @@ # # SPDX-License-Identifier: Apache-2.0 -from typing import Any, Callable, Dict -from unittest.mock import MagicMock +from typing import Any, Callable -from autogen.agentchat.conversable_agent import ConversableAgent - -try: - from crewai.tools import BaseTool as CrewAITool -except ImportError: - CrewAITool = MagicMock() +from ..agentchat.conversable_agent import ConversableAgent __all__ = ["Tool"] diff --git a/test/interop/pydantic_ai/test_pydantic_ai_tool.py b/test/interop/pydantic_ai/test_pydantic_ai_tool.py new file mode 100644 index 0000000000..d6c1d942f9 --- /dev/null +++ b/test/interop/pydantic_ai/test_pydantic_ai_tool.py @@ -0,0 +1,74 @@ +# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai +# +# SPDX-License-Identifier: Apache-2.0 + +import sys +import unittest + +import pytest + +from autogen import AssistantAgent + +if sys.version_info >= (3, 9): + from pydantic_ai.tools import Tool + + from autogen.interop.pydantic_ai.pydantic_ai_tool import PydanticAITool as AG2PydanticAITool +else: + Tool = unittest.mock.MagicMock() + AG2PydanticAITool = unittest.mock.MagicMock() + + +# skip if python version is not >= 3.9 +@pytest.mark.skipif( + sys.version_info < (3, 9), reason="Only Python 3.9 and above are supported for LangchainInteroperability" +) +class TestPydanticAITool: + def test_register_for_llm(self) -> None: + def foobar(a: int, b: str, c: dict[str, list[float]]) -> str: # type: ignore[misc] + """Get me foobar. + + Args: + a: apple pie + b: banana cake + c: carrot smoothie + """ + return f"{a} {b} {c}" + + tool = Tool(foobar) + ag2_tool = AG2PydanticAITool( + name=tool.name, + description=tool.description, + func=tool.function, + parameters_json_schema=tool._parameters_json_schema, + ) + config_list = [{"model": "gpt-4o", "api_key": "abc"}] + chatbot = AssistantAgent( + name="chatbot", + llm_config={"config_list": config_list}, + ) + ag2_tool.register_for_llm(chatbot) + expected_tools = [ + { + "type": "function", + "function": { + "name": "foobar", + "description": "Get me foobar.", + "parameters": { + "properties": { + "a": {"description": "apple pie", "title": "A", "type": "integer"}, + "b": {"description": "banana cake", "title": "B", "type": "string"}, + "c": { + "additionalProperties": {"items": {"type": "number"}, "type": "array"}, + "description": "carrot smoothie", + "title": "C", + "type": "object", + }, + }, + "required": ["a", "b", "c"], + "type": "object", + "additionalProperties": False, + }, + }, + } + ] + assert chatbot.llm_config["tools"] == expected_tools # type: ignore[index] From 4fe3a91d5f7c85ba3e4a2aceb1d36e6562ccd486 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 19 Dec 2024 16:04:58 +0100 Subject: [PATCH 61/70] polishing --- autogen/coding/jupyter/embedded_ipython_code_executor.py | 1 - 1 file changed, 1 deletion(-) diff --git a/autogen/coding/jupyter/embedded_ipython_code_executor.py b/autogen/coding/jupyter/embedded_ipython_code_executor.py index f38e06a0b4..09e4a06043 100644 --- a/autogen/coding/jupyter/embedded_ipython_code_executor.py +++ b/autogen/coding/jupyter/embedded_ipython_code_executor.py @@ -13,7 +13,6 @@ from queue import Empty from typing import Any, ClassVar, List -import jupyter_kernel_gateway from jupyter_client import KernelManager # type: ignore[attr-defined] from jupyter_client.kernelspec import KernelSpecManager from pydantic import BaseModel, Field, field_validator From 919c04ed3b10d92bb2c73a33ebd4a24b88850505 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 19 Dec 2024 16:05:25 +0100 Subject: [PATCH 62/70] polishing --- autogen/coding/jupyter/embedded_ipython_code_executor.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/autogen/coding/jupyter/embedded_ipython_code_executor.py b/autogen/coding/jupyter/embedded_ipython_code_executor.py index 09e4a06043..dfaa2d1d36 100644 --- a/autogen/coding/jupyter/embedded_ipython_code_executor.py +++ b/autogen/coding/jupyter/embedded_ipython_code_executor.py @@ -11,7 +11,7 @@ import uuid from pathlib import Path from queue import Empty -from typing import Any, ClassVar, List +from typing import Any, List from jupyter_client import KernelManager # type: ignore[attr-defined] from jupyter_client.kernelspec import KernelSpecManager From 4d3c07984e39dffd9070b5e6c11e3174b6180a65 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Thu, 19 Dec 2024 15:26:57 +0000 Subject: [PATCH 63/70] Interoperability blog wip --- .../index.mdx | 287 ++++++++++++++++++ 1 file changed, 287 insertions(+) diff --git a/website/blog/2024-12-18-Tools-interoperability/index.mdx b/website/blog/2024-12-18-Tools-interoperability/index.mdx index 605141aab6..6c96b10669 100644 --- a/website/blog/2024-12-18-Tools-interoperability/index.mdx +++ b/website/blog/2024-12-18-Tools-interoperability/index.mdx @@ -98,6 +98,8 @@ message = "Tell me about the history of the United States" user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2) ``` +Output: + ```console User (to chatbot): @@ -136,4 +138,289 @@ This overview covers the early formation and foundational moments of what became -------------------------------------------------------------------------------- ``` +## CrewAI Tools Integration + +CrewAI provides a variety of powerful tools designed for tasks such as web scraping, search, code interpretation, and more. These tools are easy to integrate into the AG2 framework, allowing you to enhance your agents with advanced capabilities. You can explore the full list of available tools in the [CrewAI Tools](https://github.com/crewAIInc/crewAI-tools/tree/main) repository. + +### Installation +Install the required packages for integrating CrewAI tools into the AG2 framework. +This ensures all dependencies for both frameworks are installed. + +```bash +pip install ag2[interop-crewai] +``` + +### Imports + +Import necessary modules and tools. +- `ScrapeWebsiteTool` are the CrewAI tools for web scraping +- `AssistantAgent` and `UserProxyAgent` are core AG2 classes. +- `Interoperability`: This module acts as a bridge, making it easier to integrate CrewAI tools with AG2’s architecture. + +```python +import os + +from crewai_tools import ScrapeWebsiteTool + +from autogen import AssistantAgent, UserProxyAgent +from autogen.interop import Interoperability +``` + +### Agent Configuration + +Configure the agents for the interaction. +- `config_list` defines the LLM configurations, including the model and API key. +- `UserProxyAgent` simulates user inputs without requiring actual human interaction (set to `NEVER`). +- `AssistantAgent` represents the AI agent, configured with the LLM settings. + +```python +config_list = [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}] +user_proxy = UserProxyAgent( + name="User", + human_input_mode="NEVER", +) + +chatbot = AssistantAgent( + name="chatbot", + llm_config={"config_list": config_list}, +) +``` + +### Tool Integration + +Initialize and register the CrewAI tool with AG2. +- `crewai_tool` is an instance of the `ScrapeWebsiteTool` from CrewAI. +- `Interoperability` converts the CrewAI tool to make it usable in AG2. +- `register_for_execution` and `register_for_llm` allow the tool to work with the UserProxyAgent and AssistantAgent. + +```python +interop = Interoperability() +crewai_tool = ScrapeWebsiteTool() +ag2_tool = interop.convert_tool(tool=crewai_tool, type="crewai") + +ag2_tool.register_for_execution(user_proxy) +ag2_tool.register_for_llm(chatbot) + +message = "Scrape the website https://ag2.ai/" + +chat_result = user_proxy.initiate_chat(recipient=chatbot, message=message, max_turns=2) +``` + +Output: + +```console +User (to chatbot): + +Scrape the website https://ag2.ai/ + +-------------------------------------------------------------------------------- +chatbot (to User): + +***** Suggested tool call (call_ZStuwmexfN7j56uJKOi6BCid): Read_website_content ***** +Arguments: +{"args":{"website_url":"https://ag2.ai/"}} +************************************************************************************* + +-------------------------------------------------------------------------------- + +>>>>>>>> EXECUTING FUNCTION Read_website_content... +Using Tool: Read website content +User (to chatbot): + +***** Response from calling tool (call_ZStuwmexfN7j56uJKOi6BCid) ***** + +AgentOS +Join our growing community of over 20,000 agent builders Join our growing community of over 20,000 agent builders The Open-Source AgentOS Build production-ready multi-agent systems in minutes, not months. Github Discord The End-to-End Platform for Multi-Agent Automation The End-to-End Platform for Multi-Agent Automation Flexible Agent Construction and Orchestration Create specialized agents that work together seamlessly. AG2 makes it easy to define roles, configure behaviors, and orchestrate collaboration - all through simple, intuitive code. → Assistant agents for problem-solving → Executor agents for taking action → Critic agents for validation → Group chat managers for coordination Built-in Conversation Patterns Built-in Conversation Patterns Stop wrestling with agent coordination. AG2 handles message routing, state management, and conversation flow automatically. → Two-agent conversations → Group chats with dynamic speaker selection → Sequential chats with context carryover → Nested conversations for modularity Seamless Human-AI collaboration Seamless Human-AI collaboration Seamlessly integrate human oversight and input into your agent workflows. → Configurable human input modes → Flexible intervention points → Optional human approval workflows → Interactive conversation interfaces → Context-aware human handoff Roadmap AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 STUDIO → Visual agent system design → Real-time testing and debugging → One-click deployment to production → Perfect for prototyping and MVPs AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders AG2 MARKETPLACE → Share and monetize your agents → Discover pre-built solution templates → Quick-start your agent development → Connect with other builders SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls SCALING TOOLS → Zero to production deployment guides → Usage analytics and cost optimization → Team collaboration features → Enterprise-ready security controls Whether you're a solo founder prototyping the next big AI product, or an enterprise team deploying at scale we're building AG2 for you. This is AgentOS - making multi-agent development accessible to everyone. Github Join Our Growing Community Join Our Growing Community → 20,000+ active agent builders → Daily technical discussions → Weekly community calls → Open RFC process → Regular contributor events (Coming soon) Discord Problem Features Roadmap Community Documentation Problem Features Roadmap Community Documentation Problem Features Roadmap Community Documentation + +********************************************************************** + +-------------------------------------------------------------------------------- +chatbot (to User): + +The website "https://ag2.ai/" promotes a platform named AgentOS, which is designed for building multi-agent systems efficiently. Key highlights from the website are: + +- **Community**: They have a growing community of over 20,000 agent builders. + +- **End-to-End Platform**: AG2 is described as an end-to-end platform for multi-agent automation. It supports flexible agent construction and orchestration, helping to define roles, configure behaviors, and orchestrate collaboration. + +- **Agent Types**: It includes assistant agents for problem-solving, executor agents for taking action, critic agents for validation, and group chat managers for coordination. + +- **Built-in Conversation Patterns**: AG2 offers capabilities for message routing, state management, and conversation flow management, supporting various conversation types like two-agent conversations, group chats, and nested conversations. + +- **Human-AI Collaboration**: The platform facilitates seamless integration of human oversight and input, with options for human intervention and approval workflows. + +- **AG2 Studio**: This feature provides visual agent system design, real-time testing, debugging, and one-click deployment, suited for prototyping and MVPs. + +- **AG2 Marketplace**: Provides a place to share, monetize agents, discover pre-built solution templates, and connect with other builders. + +- **Scaling Tools**: Includes guides for deployment, analytics, cost optimization, team collaboration features, and enterprise-ready security controls. + +- **Community and Documentation**: They encourage connecting through GitHub and Discord and have regular community calls and events planned. + +This comprehensive platform seems to aim at both individual developers and enterprise teams looking to deploy multi-agent systems effectively and collaboratively. TERMINATE + +-------------------------------------------------------------------------------- +``` + +```python +print(chat_result.summary) +``` + +Output: + +```console +The website "https://ag2.ai/" promotes a platform named AgentOS, which is designed for building multi-agent systems efficiently. Key highlights from the website are: + +- **Community**: They have a growing community of over 20,000 agent builders. + +- **End-to-End Platform**: AG2 is described as an end-to-end platform for multi-agent automation. It supports flexible agent construction and orchestration, helping to define roles, configure behaviors, and orchestrate collaboration. + +- **Agent Types**: It includes assistant agents for problem-solving, executor agents for taking action, critic agents for validation, and group chat managers for coordination. + +- **Built-in Conversation Patterns**: AG2 offers capabilities for message routing, state management, and conversation flow management, supporting various conversation types like two-agent conversations, group chats, and nested conversations. + +- **Human-AI Collaboration**: The platform facilitates seamless integration of human oversight and input, with options for human intervention and approval workflows. + +- **AG2 Studio**: This feature provides visual agent system design, real-time testing, debugging, and one-click deployment, suited for prototyping and MVPs. + +- **AG2 Marketplace**: Provides a place to share, monetize agents, discover pre-built solution templates, and connect with other builders. + +- **Scaling Tools**: Includes guides for deployment, analytics, cost optimization, team collaboration features, and enterprise-ready security controls. + +- **Community and Documentation**: They encourage connecting through GitHub and Discord and have regular community calls and events planned. + +This comprehensive platform seems to aim at both individual developers and enterprise teams looking to deploy multi-agent systems effectively and collaboratively. +``` + +## PydanticAI Tools Integration + +[PydanticAI](https://ai.pydantic.dev/) is a newer framework that offers powerful capabilities for working with LLMs. Although it currently does not have a repository with pre-built tools, it provides features like **dependency injection**, allowing you to inject a "Context" into a tool for better execution without relying on LLMs. This context can be used for passing parameters or managing state during the execution of a tool. While the framework is still growing, you can integrate its tools into AG2 to enhance agent capabilities, especially for tasks that involve structured data and context-driven logic. + +### Installation +To integrate LangChain tools into the AG2 framework, install the required dependencies: + +```bash +pip install ag2[interop-pydantic-ai] +``` + + +## Imports + +Import necessary modules and tools. +- `BaseModel`: Used to define data structures for tool inputs and outputs. +- `RunContext`: Provides context during the execution of tools. +- `PydanticAITool`: Represents a tool in the PydanticAI framework. +- `AssistantAgent` and `UserProxyAgent`: Agents that facilitate communication in the AG2 framework. +- `Interoperability`: This module acts as a bridge, making it easier to integrate PydanticAI tools with AG2’s architecture. + +```python +import os +from typing import Optional + +from pydantic import BaseModel +from pydantic_ai import RunContext +from pydantic_ai.tools import Tool as PydanticAITool + +from autogen import AssistantAgent, UserProxyAgent +from autogen.interop import Interoperability +``` + +### Agent Configuration + +Configure the agents for the interaction. +- `config_list` defines the LLM configurations, including the model and API key. +- `UserProxyAgent` simulates user inputs without requiring actual human interaction (set to `NEVER`). +- `AssistantAgent` represents the AI agent, configured with the LLM settings. + +```python +config_list = [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}] +user_proxy = UserProxyAgent( + name="User", + human_input_mode="NEVER", +) + +chatbot = AssistantAgent( + name="chatbot", + llm_config={"config_list": config_list}, +) +``` + +### Tool Integration + +Integrate the PydanticAI tool with AG2. + +- Define a `Player` model using `BaseModel` to structure the input data. +- Use `RunContext` to securely inject dependencies (like the `Player` instance) into the tool function without exposing them to the LLM. +- Implement `get_player` to define the tool's functionality, accessing `ctx.deps` for injected data. +- Convert the tool to an AG2-compatible format with `Interoperability` and register it for execution and LLM communication. +- Convert the PydanticAI tool into an AG2-compatible format using `convert_tool`. +- Register the tool for both execution and communication with the LLM by associating it with the `user_proxy` and `chatbot`. + +```python +class Player(BaseModel): + name: str + age: int + + +def get_player(ctx: RunContext[Player], additional_info: Optional[str] = None) -> str: # type: ignore[valid-type] + """Get the player's name. + + Args: + additional_info: Additional information which can be used. + """ + return f"Name: {ctx.deps.name}, Age: {ctx.deps.age}, Additional info: {additional_info}" # type: ignore[attr-defined] + + +interop = Interoperability() +pydantic_ai_tool = PydanticAITool(get_player, takes_ctx=True) + +# player will be injected as a dependency +player = Player(name="Luka", age=25) +ag2_tool = interop.convert_tool(tool=pydantic_ai_tool, type="pydanticai", deps=player) + +ag2_tool.register_for_execution(user_proxy) +ag2_tool.register_for_llm(chatbot) +``` + +Initiate a conversation between the `UserProxyAgent` and the `AssistantAgent`. + +- Use the `initiate_chat` method to send a message from the `user_proxy` to the `chatbot`. +- In this example, the user requests the chatbot to retrieve player information, providing "goal keeper" as additional context. +- The `Player` instance is securely injected into the tool using `RunContext`, ensuring the chatbot can retrieve and use this data during the interaction. + +```python +user_proxy.initiate_chat( + recipient=chatbot, message="Get player, for additional information use 'goal keeper'", max_turns=3 +) +``` + +Output: + +```console +User (to chatbot): + +Get player, for additional information use 'goal keeper' + +-------------------------------------------------------------------------------- +chatbot (to User): + +***** Suggested tool call (call_lPXIohFiJfnjmgwDnNFPQCzc): get_player ***** +Arguments: +{"additional_info":"goal keeper"} +*************************************************************************** + +-------------------------------------------------------------------------------- + +>>>>>>>> EXECUTING FUNCTION get_player... +User (to chatbot): + +***** Response from calling tool (call_lPXIohFiJfnjmgwDnNFPQCzc) ***** +Name: Luka, Age: 25, Additional info: goal keeper +********************************************************************** + +-------------------------------------------------------------------------------- +chatbot (to User): + +The player's name is Luka, who is a 25-year-old goalkeeper. TERMINATE +``` From 88d6add6ee897fc1ddf50150ebc37e012aec1a4a Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 19 Dec 2024 16:35:08 +0100 Subject: [PATCH 64/70] test fixing --- autogen/interop/crewai/crewai.py | 1 - autogen/interop/langchain/langchain.py | 1 - autogen/interop/pydantic_ai/pydantic_ai.py | 1 - test/interop/langchain/test_langchain.py | 13 ++++++------- test/interop/pydantic_ai/test_pydantic_ai.py | 4 ++-- test/interop/pydantic_ai/test_pydantic_ai_tool.py | 10 +++++----- 6 files changed, 13 insertions(+), 17 deletions(-) diff --git a/autogen/interop/crewai/crewai.py b/autogen/interop/crewai/crewai.py index 1588ccd529..cfaa9f5ada 100644 --- a/autogen/interop/crewai/crewai.py +++ b/autogen/interop/crewai/crewai.py @@ -7,7 +7,6 @@ from typing import Any, Optional from ...tools import Tool -from ..interoperable import Interoperable from ..registry import register_interoperable_class __all__ = ["CrewAIInteroperability"] diff --git a/autogen/interop/langchain/langchain.py b/autogen/interop/langchain/langchain.py index 3471e83203..a6689d4dad 100644 --- a/autogen/interop/langchain/langchain.py +++ b/autogen/interop/langchain/langchain.py @@ -6,7 +6,6 @@ from typing import Any, Optional from ...tools import Tool -from ..interoperable import Interoperable from ..registry import register_interoperable_class __all__ = ["LangChainInteroperability"] diff --git a/autogen/interop/pydantic_ai/pydantic_ai.py b/autogen/interop/pydantic_ai/pydantic_ai.py index db2e22dd4b..78c48dc0cd 100644 --- a/autogen/interop/pydantic_ai/pydantic_ai.py +++ b/autogen/interop/pydantic_ai/pydantic_ai.py @@ -9,7 +9,6 @@ from inspect import signature from typing import Any, Callable, Optional -from ..interoperability import Interoperable from ..registry import register_interoperable_class from .pydantic_ai_tool import PydanticAITool as AG2PydanticAITool diff --git a/test/interop/langchain/test_langchain.py b/test/interop/langchain/test_langchain.py index 376612ad11..cbd038d8a5 100644 --- a/test/interop/langchain/test_langchain.py +++ b/test/interop/langchain/test_langchain.py @@ -14,12 +14,11 @@ from autogen.interop import Interoperable if sys.version_info >= (3, 9): - from langchain.tools import tool - - from autogen.interop.langchain import LangChainInteroperability + from langchain.tools import tool as langchain_tool else: - tool = unittest.mock.MagicMock() - LangChainInteroperability = unittest.mock.MagicMock() + langchain_tool = unittest.mock.MagicMock() + +from autogen.interop.langchain import LangChainInteroperability # skip if python version is not >= 3.9 @@ -32,7 +31,7 @@ def setup(self) -> None: class SearchInput(BaseModel): query: str = Field(description="should be a search query") - @tool("search-tool", args_schema=SearchInput, return_direct=True) # type: ignore[misc] + @langchain_tool("search-tool", args_schema=SearchInput, return_direct=True) # type: ignore[misc] def search(query: SearchInput) -> str: """Look up things online.""" return "LangChain Integration" @@ -90,7 +89,7 @@ def test_get_unsupported_reason(self) -> None: class TestLangChainInteroperabilityWithoutPydanticInput: @pytest.fixture(autouse=True) def setup(self) -> None: - @tool + @langchain_tool def search(query: str, max_length: int) -> str: """Look up things online.""" return f"LangChain Integration, max_length: {max_length}" diff --git a/test/interop/pydantic_ai/test_pydantic_ai.py b/test/interop/pydantic_ai/test_pydantic_ai.py index 764a44e855..4f0a2da458 100644 --- a/test/interop/pydantic_ai/test_pydantic_ai.py +++ b/test/interop/pydantic_ai/test_pydantic_ai.py @@ -20,11 +20,11 @@ from pydantic_ai import RunContext from pydantic_ai.tools import Tool as PydanticAITool - from autogen.interop.pydantic_ai import PydanticAIInteroperability else: RunContext = unittest.mock.MagicMock() PydanticAITool = unittest.mock.MagicMock() - PydanticAIInteroperability = unittest.mock.MagicMock() + +from autogen.interop.pydantic_ai import PydanticAIInteroperability # skip if python version is not >= 3.9 diff --git a/test/interop/pydantic_ai/test_pydantic_ai_tool.py b/test/interop/pydantic_ai/test_pydantic_ai_tool.py index d6c1d942f9..f5588ad8b6 100644 --- a/test/interop/pydantic_ai/test_pydantic_ai_tool.py +++ b/test/interop/pydantic_ai/test_pydantic_ai_tool.py @@ -10,12 +10,12 @@ from autogen import AssistantAgent if sys.version_info >= (3, 9): - from pydantic_ai.tools import Tool + from pydantic_ai.tools import Tool as PydanticAITool - from autogen.interop.pydantic_ai.pydantic_ai_tool import PydanticAITool as AG2PydanticAITool else: - Tool = unittest.mock.MagicMock() - AG2PydanticAITool = unittest.mock.MagicMock() + PydanticAITool = unittest.mock.MagicMock() + +from autogen.interop.pydantic_ai.pydantic_ai_tool import PydanticAITool as AG2PydanticAITool # skip if python version is not >= 3.9 @@ -34,7 +34,7 @@ def foobar(a: int, b: str, c: dict[str, list[float]]) -> str: # type: ignore[mi """ return f"{a} {b} {c}" - tool = Tool(foobar) + tool = PydanticAITool(foobar) ag2_tool = AG2PydanticAITool( name=tool.name, description=tool.description, From f080fb1f1546a72027a44a35ef6110ac0e0fa9bb Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Thu, 19 Dec 2024 17:05:10 +0100 Subject: [PATCH 65/70] Update interoperability blog --- .../index.mdx | 25 +++++++++---------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/website/blog/2024-12-18-Tools-interoperability/index.mdx b/website/blog/2024-12-18-Tools-interoperability/index.mdx index 6c96b10669..2fe5fb7a62 100644 --- a/website/blog/2024-12-18-Tools-interoperability/index.mdx +++ b/website/blog/2024-12-18-Tools-interoperability/index.mdx @@ -6,17 +6,17 @@ tags: [LLM, tools, langchain, crewai, pydanticai] --- **TL;DR** -AG2 lets you integrate tools from different frameworks like **LangChain**, **CrewAI** and **PydanticAI**. +AG2 lets you bring in tools from different frameworks like **LangChain**, **CrewAI**, and **PydanticAI**. -- **LangChain**: Quickly bring in tools for tasks like API querying and web scraping. -- **CrewAI**: Use a wide variety of tools for web scraping, search, and more. -- **PydanticAI**: Leverage dependency injection for context-driven tools and structured data processing. -This integration allows you to combine and use tools from multiple frameworks within AG2, expanding your agents' capabilities. +- **LangChain**: Useful for tasks like API querying and web scraping. +- **CrewAI**: Offers a variety of tools for web scraping, search, and more. +- **PydanticAI**: Adds context-driven tools and structured data processing. -In this post, we will demonstrate how to integrate LLM tools from various frameworks—including [LangChain Tools](https://python.langchain.com/v0.1/docs/modules/tools), -[CrewAI Tools](https://github.com/crewAIInc/crewAI-tools/tree/main) and [PydanticAI Tools](https://ai.pydantic.dev/tools/) into the AG2 framework. -This process enables smooth interoperability between these systems, allowing developers to leverage the unique capabilities of each toolset within AG2's flexible agent-based architecture. -By the end of this post, you will understand how to configure agents, adapt these tools for use in AG2, and validate the integration through practical examples. +With AG2, you can combine these tools and enhance your agents' capabilities. + +In this post, we’ll walk through how to integrate tools from various frameworks—like [LangChain Tools](https://python.langchain.com/v0.1/docs/modules/tools), +[CrewAI Tools](https://github.com/crewAIInc/crewAI-tools/tree/main), and [PydanticAI Tools](https://ai.pydantic.dev/tools/)—into AG2. +This allows you to use tools from different frameworks within AG2, giving your agents more power and flexibility. You’ll see how to set up agents, adapt the tools, and validate the integration through examples.his post, you will understand how to configure agents, adapt these tools for use in AG2, and validate the integration through practical examples. ## LangChain Tools Integration @@ -109,7 +109,7 @@ Tell me about the history of the United States chatbot (to User): ***** Suggested tool call (call_hhy2G43ymytUFmJlDsK9J0tk): wikipedia ***** -Arguments: +Arguments: {"tool_input":{"query":"history of the United States"}} ************************************************************************** @@ -217,7 +217,7 @@ Scrape the website https://ag2.ai/ chatbot (to User): ***** Suggested tool call (call_ZStuwmexfN7j56uJKOi6BCid): Read_website_content ***** -Arguments: +Arguments: {"args":{"website_url":"https://ag2.ai/"}} ************************************************************************************* @@ -405,7 +405,7 @@ Get player, for additional information use 'goal keeper' chatbot (to User): ***** Suggested tool call (call_lPXIohFiJfnjmgwDnNFPQCzc): get_player ***** -Arguments: +Arguments: {"additional_info":"goal keeper"} *************************************************************************** @@ -423,4 +423,3 @@ chatbot (to User): The player's name is Luka, who is a 25-year-old goalkeeper. TERMINATE ``` - From 4394aaf163b4f0e6bfb345603e363c2148e88994 Mon Sep 17 00:00:00 2001 From: Robert Jambrecic Date: Thu, 19 Dec 2024 17:11:25 +0100 Subject: [PATCH 66/70] Update interoperability blog --- website/blog/2024-12-18-Tools-interoperability/index.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/website/blog/2024-12-18-Tools-interoperability/index.mdx b/website/blog/2024-12-18-Tools-interoperability/index.mdx index 2fe5fb7a62..3f6ae0962d 100644 --- a/website/blog/2024-12-18-Tools-interoperability/index.mdx +++ b/website/blog/2024-12-18-Tools-interoperability/index.mdx @@ -304,7 +304,7 @@ pip install ag2[interop-pydantic-ai] ``` -## Imports +### Imports Import necessary modules and tools. - `BaseModel`: Used to define data structures for tool inputs and outputs. From 6d2ee6e02a01952fb476326d3cc1c315109271f1 Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 19 Dec 2024 22:04:46 +0100 Subject: [PATCH 67/70] fix setup --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index c438608894..fd9758aa40 100644 --- a/setup.py +++ b/setup.py @@ -74,7 +74,7 @@ interop_pydantic_ai = ["pydantic-ai>=0.0.13,<1; python_version>='3.9'"] interop = interop_crewai + interop_langchain + interop_pydantic_ai -types = (["mypy==1.9.0", "pytest"] + jupyter_executor + interop,) +types = ["mypy==1.9.0", "pytest"] + jupyter_executor + interop if current_os in ["Windows", "Darwin"]: retrieve_chat_pgvector.extend(["psycopg[binary]>=3.1.18"]) From ba01c097a7dbe82eeaeb83ed118131f82b7ee1bd Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 19 Dec 2024 23:15:35 +0100 Subject: [PATCH 68/70] fix setup --- setup.py | 4 +--- test/interop/langchain/test_langchain.py | 4 ++-- test/interop/pydantic_ai/test_pydantic_ai.py | 12 ++++++------ test/interop/pydantic_ai/test_pydantic_ai_tool.py | 2 +- 4 files changed, 10 insertions(+), 12 deletions(-) diff --git a/setup.py b/setup.py index 2ed2644270..649baae863 100644 --- a/setup.py +++ b/setup.py @@ -59,8 +59,6 @@ "ipykernel>=6.29.0", ] -types = ["mypy==1.9.0"] + test + jupyter_executor - retrieve_chat = [ "protobuf==4.25.3", "chromadb==0.5.3", @@ -87,7 +85,7 @@ interop_pydantic_ai = ["pydantic-ai>=0.0.13,<1; python_version>='3.9'"] interop = interop_crewai + interop_langchain + interop_pydantic_ai -types = ["mypy==1.9.0", "pytest"] + jupyter_executor + interop +types = ["mypy==1.9.0"] + test + jupyter_executor + interop if current_os in ["Windows", "Darwin"]: retrieve_chat_pgvector.extend(["psycopg[binary]>=3.1.18"]) diff --git a/test/interop/langchain/test_langchain.py b/test/interop/langchain/test_langchain.py index cbd038d8a5..be0a2f6bfc 100644 --- a/test/interop/langchain/test_langchain.py +++ b/test/interop/langchain/test_langchain.py @@ -50,7 +50,7 @@ def test_convert_tool(self) -> None: assert self.tool.name == "search-tool" assert self.tool.description == "Look up things online." - tool_input = self.model_type(query="LangChain") + tool_input = self.model_type(query="LangChain") # type: ignore[misc] assert self.tool.func(tool_input=tool_input) == "LangChain Integration" @pytest.mark.skipif(skip_openai, reason=reason) @@ -101,7 +101,7 @@ def test_convert_tool(self) -> None: assert self.tool.name == "search" assert self.tool.description == "Look up things online." - tool_input = self.model_type(query="LangChain", max_length=100) + tool_input = self.model_type(query="LangChain", max_length=100) # type: ignore[misc] assert self.tool.func(tool_input=tool_input) == "LangChain Integration, max_length: 100" @pytest.mark.skipif(skip_openai, reason=reason) diff --git a/test/interop/pydantic_ai/test_pydantic_ai.py b/test/interop/pydantic_ai/test_pydantic_ai.py index 4f0a2da458..2840cdbc9a 100644 --- a/test/interop/pydantic_ai/test_pydantic_ai.py +++ b/test/interop/pydantic_ai/test_pydantic_ai.py @@ -38,7 +38,7 @@ def roll_dice() -> str: """Roll a six-sided dice and return the result.""" return str(random.randint(1, 6)) - pydantic_ai_tool = PydanticAITool(roll_dice, max_retries=3) + pydantic_ai_tool = PydanticAITool(roll_dice, max_retries=3) # type: ignore[var-annotated] self.tool = PydanticAIInteroperability.convert_tool(pydantic_ai_tool) def test_type_checks(self) -> None: @@ -95,10 +95,10 @@ def f( ctx = RunContext( deps=123, retry=0, - messages=None, + messages=None, # type: ignore[arg-type] tool_name=f.__name__, ) - pydantic_ai_tool = PydanticAITool(f, takes_ctx=True) + pydantic_ai_tool = PydanticAITool(f, takes_ctx=True) # type: ignore[var-annotated] g = PydanticAIInteroperability.inject_params( ctx=ctx, tool=pydantic_ai_tool, @@ -119,11 +119,11 @@ def f( ctx = RunContext( deps=123, retry=0, - messages=None, + messages=None, # type: ignore[arg-type] tool_name=f.__name__, ) - pydantic_ai_tool = PydanticAITool(f, takes_ctx=True, max_retries=3) + pydantic_ai_tool = PydanticAITool(f, takes_ctx=True, max_retries=3) # type: ignore[var-annotated] g = PydanticAIInteroperability.inject_params( ctx=ctx, tool=pydantic_ai_tool, @@ -158,7 +158,7 @@ def get_player(ctx: RunContext[Player], additional_info: Optional[str] = None) - """ return f"Name: {ctx.deps.name}, Age: {ctx.deps.age}, Additional info: {additional_info}" # type: ignore[attr-defined] - self.pydantic_ai_tool = PydanticAITool(get_player, takes_ctx=True) + self.pydantic_ai_tool = PydanticAITool(get_player, takes_ctx=True) # type: ignore[var-annotated] player = Player(name="Luka", age=25) self.tool = PydanticAIInteroperability.convert_tool(tool=self.pydantic_ai_tool, deps=player) diff --git a/test/interop/pydantic_ai/test_pydantic_ai_tool.py b/test/interop/pydantic_ai/test_pydantic_ai_tool.py index f5588ad8b6..f1ae38389e 100644 --- a/test/interop/pydantic_ai/test_pydantic_ai_tool.py +++ b/test/interop/pydantic_ai/test_pydantic_ai_tool.py @@ -34,7 +34,7 @@ def foobar(a: int, b: str, c: dict[str, list[float]]) -> str: # type: ignore[mi """ return f"{a} {b} {c}" - tool = PydanticAITool(foobar) + tool = PydanticAITool(foobar) # type: ignore[var-annotated] ag2_tool = AG2PydanticAITool( name=tool.name, description=tool.description, From bd877d219e10c57e8b61bd68fa6fa95e7d5dc44f Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 19 Dec 2024 23:41:21 +0100 Subject: [PATCH 69/70] fix version of Pydantic AI --- setup.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index 649baae863..04a89a00e0 100644 --- a/setup.py +++ b/setup.py @@ -81,8 +81,8 @@ ] interop_crewai = ["crewai[tools]>=0.86,<1; python_version>='3.10' and python_version<'3.13'"] -interop_langchain = ["langchain-community>=0.3.12,<1; python_version>='3.9'"] -interop_pydantic_ai = ["pydantic-ai>=0.0.13,<1; python_version>='3.9'"] +interop_langchain = ["langchain-community>=0.3.12,<1"] +interop_pydantic_ai = ["pydantic-ai==0.0.13"] interop = interop_crewai + interop_langchain + interop_pydantic_ai types = ["mypy==1.9.0"] + test + jupyter_executor + interop From ecf77c5d7ccae3f922fd460582d1f0ba3a6d344b Mon Sep 17 00:00:00 2001 From: Davor Runje Date: Thu, 19 Dec 2024 23:56:49 +0100 Subject: [PATCH 70/70] CI fix --- autogen/coding/jupyter/embedded_ipython_code_executor.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/autogen/coding/jupyter/embedded_ipython_code_executor.py b/autogen/coding/jupyter/embedded_ipython_code_executor.py index dfaa2d1d36..231dca0ffd 100644 --- a/autogen/coding/jupyter/embedded_ipython_code_executor.py +++ b/autogen/coding/jupyter/embedded_ipython_code_executor.py @@ -13,6 +13,8 @@ from queue import Empty from typing import Any, List +# this is needed for CI to work. The import of this file should fail if jupyter-kernel-gateway is not installed +import jupyter_kernel_gateway from jupyter_client import KernelManager # type: ignore[attr-defined] from jupyter_client.kernelspec import KernelSpecManager from pydantic import BaseModel, Field, field_validator