A programming framework for agentic AI
Anthropic Client (#2931)
HRUSHIKESH DOKALA32fa709e13e6
diff --git a/.github/workflows/contrib-tests.yml b/.github/workflows/contrib-tests.ymlindex ebce2cd4e..05e7349d1 100644--- a/.github/workflows/contrib-tests.yml+++ b/.github/workflows/contrib-tests.yml@@ -475,3 +475,46 @@ jobs:with:file: ./coverage.xmlflags: unittests+++ AnthropicTest:+ runs-on: ${{ matrix.os }}+ strategy:+ fail-fast: false+ matrix:+ os: ["ubuntu-latest", "windows-latest", "macos-latest"]+ python-version: ["3.9", "3.10", "3.11", "3.12"]++ steps:+ - uses: actions/checkout@v4+ with:+ lfs: true+ - name: Set up Python ${{ matrix.python-version }}+ uses: actions/setup-python@v5+ with:+ python-version: ${{ matrix.python-version }}+ - name: Install packages and dependencies for all tests+ run: |+ python -m pip install --upgrade pip wheel+ pip install pytest-cov>=5++ - name: Install packages and dependencies for Anthropic+ run: |+ pip install -e .[test]+ pip install -e .[anthropic]++ - name: Set AUTOGEN_USE_DOCKER based on OS+ shell: bash+ run: |+ if [[ ${{ matrix.os }} != ubuntu-latest ]]; then+ echo "AUTOGEN_USE_DOCKER=False" >> $GITHUB_ENV+ fi++ - name: Coverage+ run: |+ pytest test/oai/test_anthropic.py --skip-openai+ - name: Upload coverage to Codecov+ uses: codecov/codecov-action@v3+ with:+ file: ./coverage.xml+ flags: unittestsdiff --git a/autogen/logger/file_logger.py b/autogen/logger/file_logger.pyindex 15b2c457e..4e1513478 100644--- a/autogen/logger/file_logger.py+++ b/autogen/logger/file_logger.py@@ -17,6 +17,7 @@ from .base_logger import LLMConfigif TYPE_CHECKING:from autogen import Agent, ConversableAgent, OpenAIWrapper+ from autogen.oai.anthropic import AnthropicClientfrom autogen.oai.gemini import GeminiClientlogger = logging.getLogger(__name__)@@ -200,7 +201,10 @@ class FileLogger(BaseLogger):self.logger.error(f"[file_logger] Failed to log event {e}")def log_new_client(- self, client: AzureOpenAI | OpenAI | GeminiClient, wrapper: OpenAIWrapper, init_args: Dict[str, Any]+ self,+ client: AzureOpenAI | OpenAI | GeminiClient | AnthropicClient,+ wrapper: OpenAIWrapper,+ init_args: Dict[str, Any],) -> None:"""Log a new client instance.diff --git a/autogen/logger/sqlite_logger.py b/autogen/logger/sqlite_logger.pyindex 4ebea32cc..1e80bc875 100644--- a/autogen/logger/sqlite_logger.py+++ b/autogen/logger/sqlite_logger.py@@ -18,6 +18,7 @@ from .base_logger import LLMConfigif TYPE_CHECKING:from autogen import Agent, ConversableAgent, OpenAIWrapper+ from autogen.oai.anthropic import AnthropicClientfrom autogen.oai.gemini import GeminiClientlogger = logging.getLogger(__name__)@@ -387,7 +388,10 @@ class SqliteLogger(BaseLogger):self._run_query(query=query, args=query_args)def log_new_client(- self, client: Union[AzureOpenAI, OpenAI, GeminiClient], wrapper: OpenAIWrapper, init_args: Dict[str, Any]+ self,+ client: Union[AzureOpenAI, OpenAI, GeminiClient, AnthropicClient],+ wrapper: OpenAIWrapper,+ init_args: Dict[str, Any],) -> None:if self.con is None:returndiff --git a/autogen/oai/anthropic.py b/autogen/oai/anthropic.pynew file mode 100644index 000000000..27fbc36d8--- /dev/null+++ b/autogen/oai/anthropic.py@@ -0,0 +1,274 @@+"""+Create an OpenAI-compatible client for the Anthropic API.++Example usage:+Install the `anthropic` package by running `pip install --upgrade anthropic`.+- https://docs.anthropic.com/en/docs/quickstart-guide++import autogen++config_list = [+ {+ "model": "claude-3-sonnet-20240229",+ "api_key": os.getenv("ANTHROPIC_API_KEY"),+ "api_type": "anthropic",+ }+]++assistant = autogen.AssistantAgent("assistant", llm_config={"config_list": config_list})+"""++from __future__ import annotations++import copy+import inspect+import json+import os+import warnings+from typing import Any, Dict, List, Tuple, Union++from anthropic import Anthropic+from anthropic import __version__ as anthropic_version+from anthropic.types import Completion, Message+from client_utils import validate_parameter+from openai.types.chat import ChatCompletion, ChatCompletionMessageToolCall+from openai.types.chat.chat_completion import ChatCompletionMessage, Choice+from typing_extensions import Annotated++TOOL_ENABLED = anthropic_version >= "0.23.1"+if TOOL_ENABLED:+ from anthropic.types.tool_use_block_param import (+ ToolUseBlockParam,+ )+++ANTHROPIC_PRICING_1k = {+ "claude-3-sonnet-20240229": (0.003, 0.015),+ "claude-3-opus-20240229": (0.015, 0.075),+ "claude-2.0": (0.008, 0.024),+ "claude-2.1": (0.008, 0.024),+ "claude-3.0-opus": (0.015, 0.075),+ "claude-3.0-haiku": (0.00025, 0.00125),+}+++class AnthropicClient:+ def __init__(self, **kwargs: Any):+ """+ Initialize the Anthropic API client.+ Args:+ api_key (str): The API key for the Anthropic API or set the `ANTHROPIC_API_KEY` environment variable.+ """+ self._api_key = kwargs.get("api_key", None)++ if not self._api_key:+ self._api_key = os.getenv("ANTHROPIC_API_KEY")++ if self._api_key is None:+ raise ValueError("API key is required to use the Anthropic API.")++ self._client = Anthropic(api_key=self._api_key)+ self._last_tooluse_status = {}++ def load_config(self, params: Dict[str, Any]):+ """Load the configuration for the Anthropic API client."""+ anthropic_params = {}++ anthropic_params["model"] = params.get("model", None)+ assert anthropic_params["model"], "Please provide a `model` in the config_list to use the Anthropic API."++ anthropic_params["temperature"] = validate_parameter(+ params, "temperature", (float, int), False, 1.0, (0.0, 1.0), None+ )+ anthropic_params["max_tokens"] = validate_parameter(params, "max_tokens", int, False, 4096, (1, None), None)+ anthropic_params["top_k"] = validate_parameter(params, "top_k", int, True, None, (1, None), None)+ anthropic_params["top_p"] = validate_parameter(params, "top_p", (float, int), True, None, (0.0, 1.0), None)+ anthropic_params["stop_sequences"] = validate_parameter(params, "stop_sequences", list, True, None, None, None)+ anthropic_params["stream"] = validate_parameter(params, "stream", bool, False, False, None, None)++ if anthropic_params["stream"]:+ warnings.warn(+ "Streaming is not currently supported, streaming will be disabled.",+ UserWarning,+ )+ anthropic_params["stream"] = False++ return anthropic_params++ def cost(self, response) -> float:+ """Calculate the cost of the completion using the Anthropic pricing."""+ return response.cost++ @property+ def api_key(self):+ return self._api_key++ def create(self, params: Dict[str, Any]) -> Completion:+ """Create a completion for a given config.++ Args:+ params: The params for the completion.++ Returns:+ The completion.+ """+ if "tools" in params:+ converted_functions = self.convert_tools_to_functions(params["tools"])+ params["functions"] = params.get("functions", []) + converted_functions++ raw_contents = params["messages"]+ anthropic_params = self.load_config(params)++ processed_messages = []+ for message in raw_contents:++ if message["role"] == "system":+ params["system"] = message["content"]+ elif message["role"] == "function":+ processed_messages.append(self.return_function_call_result(message["content"]))+ elif "function_call" in message:+ processed_messages.append(self.restore_last_tooluse_status())+ elif message["content"] == "":+ message["content"] = "I'm done. Please send TERMINATE" # Not sure about this one.+ processed_messages.append(message)+ else:+ processed_messages.append(message)++ # Check for interleaving roles and correct, for Anthropic must be: user, assistant, user, etc.+ for i, message in enumerate(processed_messages):+ if message["role"] is not ("user" if i % 2 == 0 else "assistant"):+ message["role"] = "user" if i % 2 == 0 else "assistant"++ # Note: When using reflection_with_llm we may end up with an "assistant" message as the last message+ if processed_messages[-1]["role"] != "user":+ # If the last role is not user, add a continue message at the end+ continue_message = {"content": "continue", "role": "user"}+ processed_messages.append(continue_message)++ params["messages"] = processed_messages++ # TODO: support stream+ params = params.copy()+ if "functions" in params:+ tools_configs = params.pop("functions")+ tools_configs = [self.openai_func_to_anthropic(tool) for tool in tools_configs]+ params["tools"] = tools_configs++ # Anthropic doesn't accept None values, so we need to use keyword argument unpacking instead of setting parameters.+ # Copy params we need into anthropic_params+ # Remove any that don't have values+ anthropic_params["messages"] = params["messages"]+ if "system" in params:+ anthropic_params["system"] = params["system"]+ if "tools" in params:+ anthropic_params["tools"] = params["tools"]+ if anthropic_params["top_k"] is None:+ del anthropic_params["top_k"]+ if anthropic_params["top_p"] is None:+ del anthropic_params["top_p"]+ if anthropic_params["stop_sequences"] is None:+ del anthropic_params["stop_sequences"]++ response = self._client.messages.create(**anthropic_params)++ # Calculate and save the cost onto the response+ prompt_tokens = response.usage.input_tokens+ completion_tokens = response.usage.output_tokens+ response.cost = _calculate_cost(prompt_tokens, completion_tokens, anthropic_params["model"])++ return response++ def message_retrieval(self, response: Union[Message]) -> Union[List[str], List[ChatCompletionMessage]]:+ """Retrieve the messages from the response."""+ messages = response.content+ if len(messages) == 0:+ return [None]+ res = []+ if TOOL_ENABLED:+ for choice in messages:+ if choice.type == "tool_use":+ res.insert(0, self.response_to_openai_message(choice))+ self._last_tooluse_status["tool_use"] = choice.model_dump()+ else:+ res.append(choice.text)+ self._last_tooluse_status["think"] = choice.text++ return res++ else:+ return [ # type: ignore [return-value]+ choice.text if choice.message.function_call is not None else choice.message.content # type: ignore [union-attr]+ for choice in messages+ ]++ def response_to_openai_message(self, response) -> ChatCompletionMessage:+ """Convert the client response to OpenAI ChatCompletion Message"""+ dict_response = response.model_dump()+ return ChatCompletionMessage(+ content=None,+ role="assistant",+ function_call={"name": dict_response["name"], "arguments": json.dumps(dict_response["input"])},+ )++ def restore_last_tooluse_status(self) -> Dict:+ cached_content = []+ if "think" in self._last_tooluse_status:+ cached_content.append({"type": "text", "text": self._last_tooluse_status["think"]})+ cached_content.append(self._last_tooluse_status["tool_use"])+ res = {"role": "assistant", "content": cached_content}+ return res++ def return_function_call_result(self, result: str) -> Dict:+ return {+ "role": "user",+ "content": [+ {+ "type": "tool_result",+ "tool_use_id": self._last_tooluse_status["tool_use"]["id"],+ "content": result,+ }+ ],+ }++ @staticmethod+ def openai_func_to_anthropic(openai_func: dict) -> dict:+ res = openai_func.copy()+ res["input_schema"] = res.pop("parameters")+ return res++ @staticmethod+ def get_usage(response: Message) -> Dict:+ """Get the usage of tokens and their cost information."""+ return {+ "prompt_tokens": response.usage.input_tokens if response.usage is not None else 0,+ "completion_tokens": response.usage.output_tokens if response.usage is not None else 0,+ "total_tokens": (+ response.usage.input_tokens + response.usage.output_tokens if response.usage is not None else 0+ ),+ "cost": response.cost if hasattr(response, "cost") else 0.0,+ "model": response.model,+ }++ @staticmethod+ def convert_tools_to_functions(tools: List) -> List:+ functions = []+ for tool in tools:+ if tool.get("type") == "function" and "function" in tool:+ functions.append(tool["function"])++ return functions+++def _calculate_cost(input_tokens: int, output_tokens: int, model: str) -> float:+ """Calculate the cost of the completion using the Anthropic pricing."""+ total = 0.0++ if model in ANTHROPIC_PRICING_1k:+ input_cost_per_1k, output_cost_per_1k = ANTHROPIC_PRICING_1k[model]+ input_cost = (input_tokens / 1000) * input_cost_per_1k+ output_cost = (output_tokens / 1000) * output_cost_per_1k+ total = input_cost + output_cost+ else:+ warnings.warn(f"Cost calculation not available for model {model}", UserWarning)++ return totaldiff --git a/autogen/oai/client.py b/autogen/oai/client.pyindex fb5946b38..e86ecc512 100644--- a/autogen/oai/client.py+++ b/autogen/oai/client.py@@ -49,6 +49,13 @@ try:except ImportError as e:gemini_import_exception = e+try:+ from autogen.oai.anthropic import AnthropicClient++ anthropic_import_exception: Optional[ImportError] = None+except ImportError as e:+ anthropic_import_exception = e+logger = logging.getLogger(__name__)if not logger.handlers:# Add the console handler.@@ -449,6 +456,11 @@ class OpenAIWrapper:raise ImportError("Please install `google-generativeai` to use Google OpenAI API.")client = GeminiClient(**openai_config)self._clients.append(client)+ elif api_type is not None and api_type.startswith("anthropic"):+ if anthropic_import_exception:+ raise ImportError("Please install `anthropic` to use Anthropic API.")+ client = AnthropicClient(**openai_config)+ self._clients.append(client)else:client = OpenAI(**openai_config)self._clients.append(OpenAIClient(client))diff --git a/autogen/runtime_logging.py b/autogen/runtime_logging.pyindex 6ce207a2f..3d238580b 100644--- a/autogen/runtime_logging.py+++ b/autogen/runtime_logging.py@@ -13,6 +13,7 @@ from autogen.logger.logger_factory import LoggerFactoryif TYPE_CHECKING:from autogen import Agent, ConversableAgent, OpenAIWrapper+ from autogen.oai.anthropic import AnthropicClientfrom autogen.oai.gemini import GeminiClientlogger = logging.getLogger(__name__)@@ -107,7 +108,7 @@ def log_new_wrapper(wrapper: OpenAIWrapper, init_args: Dict[str, Union[LLMConfigdef log_new_client(- client: Union[AzureOpenAI, OpenAI, GeminiClient], wrapper: OpenAIWrapper, init_args: Dict[str, Any]+ client: Union[AzureOpenAI, OpenAI, GeminiClient, AnthropicClient], wrapper: OpenAIWrapper, init_args: Dict[str, Any]) -> None:if autogen_logger is None:logger.error("[runtime logging] log_new_client: autogen logger is None")diff --git a/autogen/token_count_utils.py b/autogen/token_count_utils.pyindex b71dbc428..6da6429d7 100644--- a/autogen/token_count_utils.py+++ b/autogen/token_count_utils.py@@ -119,6 +119,9 @@ def _num_token_from_messages(messages: Union[List, Dict], model="gpt-3.5-turbo-0elif "gemini" in model:logger.info("Gemini is not supported in tiktoken. Returning num tokens assuming gpt-4-0613.")return _num_token_from_messages(messages, model="gpt-4-0613")+ elif "claude" in model:+ logger.info("Claude is not supported in tiktoken. Returning num tokens assuming gpt-4-0613.")+ return _num_token_from_messages(messages, model="gpt-4-0613")else:raise NotImplementedError(f"""_num_token_from_messages() is not implemented for model {model}. See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens."""diff --git a/setup.py b/setup.pyindex d52a4e7ef..20dc5e1bf 100644--- a/setup.py+++ b/setup.py@@ -88,6 +88,7 @@ extra_require = {"jupyter-executor": jupyter_executor,"types": ["mypy==1.9.0", "pytest>=6.1.1,<8"] + jupyter_executor,"long-context": ["llmlingua<0.3"],+ "anthropic": ["anthropic>=0.23.1"],}setuptools.setup(diff --git a/test/oai/test_anthropic.py b/test/oai/test_anthropic.pynew file mode 100644index 000000000..379ab47f6--- /dev/null+++ b/test/oai/test_anthropic.py@@ -0,0 +1,97 @@+#!/usr/bin/env python3 -m pytest++import os+from unittest.mock import MagicMock, patch++import pytest++try:+ from autogen.oai.anthropic import AnthropicClient, _calculate_cost++ skip = False+except ImportError:+ AnthropicClient = object+ skip = True++from typing_extensions import Literal++reason = "Anthropic dependency not installed!"+++def mock_completion():+ class MockCompletion:+ def __init__(+ self,+ id="msg_013Zva2CMHLNnXjNJJKqJ2EF",+ completion="Hi! My name is Claude.",+ model="claude-3-opus-20240229",+ stop_reason="end_turn",+ role="assistant",+ type: Literal["completion"] = "completion",+ usage={"input_tokens": 10, "output_tokens": 25},+ ):+ self.id = id+ self.role = role+ self.completion = completion+ self.model = model+ self.stop_reason = stop_reason+ self.type = type+ self.usage = usage++ return MockCompletion+++def anthropic_client():+ return AnthropicClient(api_key="dummy_api_key")++[email protected](skip, reason=reason)+def test_initialization_missing_api_key():+ os.environ.pop("ANTHROPIC_API_KEY", None)+ with pytest.raises(ValueError, match="API key is required to use the Anthropic API."):+ AnthropicClient()++ AnthropicClient(api_key="dummy_api_key")++[email protected](skip, reason=reason)+def test_intialization(anthropic_client):+ assert anthropic_client.api_key == "dummy_api_key", "`api_key` should be correctly set in the config"+++# Test cost calculation[email protected](skip, reason=reason)+def test_cost_calculation(mock_completion):+ completion = mock_completion(+ completion="Hi! My name is Claude.",+ usage={"prompt_tokens": 10, "completion_tokens": 25, "total_tokens": 35},+ model="claude-3-opus-20240229",+ )+ assert (+ _calculate_cost(completion.usage["prompt_tokens"], completion.usage["completion_tokens"], completion.model)+ == 0.002025+ ), "Cost should be $0.002025"++[email protected](skip, reason=reason)+def test_load_config(anthropic_client):+ params = {+ "model": "claude-3-sonnet-20240229",+ "stream": False,+ "temperature": 1,+ "top_p": 0.8,+ "max_tokens": 100,+ }+ expected_params = {+ "model": "claude-3-sonnet-20240229",+ "stream": False,+ "temperature": 1,+ "top_p": 0.8,+ "max_tokens": 100,+ "stop_sequences": None,+ "top_k": None,+ }+ result = anthropic_client.load_config(params)+ assert result == expected_params, "Config should be correctly loaded"diff --git a/website/docs/topics/non-openai-models/cloud-anthropic.ipynb b/website/docs/topics/non-openai-models/cloud-anthropic.ipynbindex ec8793be4..a1e520850 100644--- a/website/docs/topics/non-openai-models/cloud-anthropic.ipynb+++ b/website/docs/topics/non-openai-models/cloud-anthropic.ipynb@@ -10,10 +10,18 @@"source": ["# Anthropic Claude\n","\n",- "In this notebook, we demonstrate how a to use Anthropic Claude model for AgentChat.\n",+ "In the v0.2.30 release of AutoGen we support Anthropic Client.\n",+ "\n",+ "Claude is a family of large language models developed by Anthropic and designed to revolutionize the way you interact with AI. Claude excels at a wide variety of tasks involving language, reasoning, analysis, coding, and more. The models are highly capable, easy to use, and can be customized to suit your needs.\n",+ "\n",+ "In this notebook, we demonstrate how to use Anthropic Claude model for AgentChat in AutoGen.\n",+ "\n",+ "## Features\n",+ "\n",+ "Additionally, this client class provides support for function/tool calling and will track token usage and cost correctly as per Anthropic's API costs (as of June 2024).\n","\n","## Requirements\n",- "To use Anthropic Claude with AutoGen, first you need to install the `pyautogen` and `anthropic` package.\n",+ "To use Anthropic Claude with AutoGen, first you need to install the `pyautogen[\"anthropic]` package.\n","\n","To try out the function call feature of Claude model, you need to install `anthropic>=0.23.1`.\n"]@@ -25,291 +33,83 @@"outputs": [],"source": ["# !pip install pyautogen\n",- "!pip install \"anthropic>=0.23.1\""- ]- },- {- "cell_type": "code",- "execution_count": 10,- "metadata": {},- "outputs": [],- "source": [- "import inspect\n",- "import json\n",- "from typing import Any, Dict, List, Union\n",- "\n",- "from anthropic import Anthropic\n",- "from anthropic import __version__ as anthropic_version\n",- "from anthropic.types import Completion, Message\n",- "from openai.types.chat.chat_completion import ChatCompletionMessage\n",- "from typing_extensions import Annotated\n",- "\n",- "import autogen\n",- "from autogen import AssistantAgent, UserProxyAgent\n",- "\n",- "TOOL_ENABLED = anthropic_version >= \"0.23.1\"\n",- "if TOOL_ENABLED:\n",- " from anthropic.types.beta.tools import ToolsBetaMessage\n",- "else:\n",- " ToolsBetaMessage = object"+ "!pip install pyautogen[\"anthropic\"]"]},{"cell_type": "markdown","metadata": {},"source": [- "## Create Anthropic Model Client following ModelClient Protocol\n",- "\n",- "We will implement our Anthropic client adhere to the `ModelClient` protocol and response structure which is defined in client.py and shown below.\n",- "\n",- "\n",- "```python\n",- "class ModelClient(Protocol):\n",- " \"\"\"\n",- " A client class must implement the following methods:\n",- " - create must return a response object that implements the ModelClientResponseProtocol\n",- " - cost must return the cost of the response\n",- " - get_usage must return a dict with the following keys:\n",- " - prompt_tokens\n",- " - completion_tokens\n",- " - total_tokens\n",- " - cost\n",- " - model\n",- "\n",- " This class is used to create a client that can be used by OpenAIWrapper.\n",- " The response returned from create must adhere to the ModelClientResponseProtocol but can be extended however needed.\n",- " The message_retrieval method must be implemented to return a list of str or a list of messages from the response.\n",- " \"\"\"\n",- "\n",- " RESPONSE_USAGE_KEYS = [\"prompt_tokens\", \"completion_tokens\", \"total_tokens\", \"cost\", \"model\"]\n",- "\n",- " class ModelClientResponseProtocol(Protocol):\n",- " class Choice(Protocol):\n",- " class Message(Protocol):\n",- " content: Optional[str]\n",- "\n",- " message: Message\n",- "\n",- " choices: List[Choice]\n",- " model: str\n",- "\n",- " def create(self, params) -> ModelClientResponseProtocol:\n",- " ...\n",- "\n",- " def message_retrieval(\n",- " self, response: ModelClientResponseProtocol\n",- " ) -> Union[List[str], List[ModelClient.ModelClientResponseProtocol.Choice.Message]]:\n",- " \"\"\"\n",- " Retrieve and return a list of strings or a list of Choice.Message from the response.\n",+ "## Set the config for the Anthropic API\n","\n",- " NOTE: if a list of Choice.Message is returned, it currently needs to contain the fields of OpenAI's ChatCompletion Message object,\n",- " since that is expected for function or tool calling in the rest of the codebase at the moment, unless a custom agent is being used.\n",- " \"\"\"\n",- " ...\n",+ "You can add any parameters that are needed for the custom model loading in the same configuration list.\n","\n",- " def cost(self, response: ModelClientResponseProtocol) -> float:\n",- " ...\n",+ "It is important to add the `api_type` field and set it to a string that corresponds to the client type used: `anthropic`.\n","\n",- " @staticmethod\n",- " def get_usage(response: ModelClientResponseProtocol) -> Dict:\n",- " \"\"\"Return usage summary of the response using RESPONSE_USAGE_KEYS.\"\"\"\n",- " ...\n",- "```\n"+ "Example:\n",+ "```\n",+ "[\n",+ " {\n",+ " \"model\": \"claude-3-sonnet-20240229\",\n",+ " \"api_key\": \"your Anthropic API Key goes here\",\n",+ " \"api_type\": \"anthropic\",\n",+ " \"temperature\": 0.5,\n",+ " \"top_p\": 0.2, # Note: It is recommended to set temperature or top_p but not both.\n",+ " \"max_tokens\": 10000,\n",+ " },\n",+ " {\n",+ " \"model\":\"claude-3-opus-20240229\",\n",+ " \"api_key\":\"your api key\",\n",+ " \"api_type\":\"anthropic\",\n",+ " },\n",+ " {\n",+ " \"model\":\"claude-2.0\",\n",+ " \"api_key\":\"your api key\",\n",+ " \"api_type\":\"anthropic\",\n",+ " },\n",+ " {\n",+ " \"model\":\"claude-2.1\",\n",+ " \"api_key\":\"your api key\",\n",+ " \"api_type\":\"anthropic\",\n",+ " },\n",+ " {\n",+ " \"model\":\"claude-3.0-haiku\",\n",+ " \"api_key\":\"your api key\",\n",+ " \"api_type\":\"anthropic\",\n",+ " },\n",+ "]\n",+ "```"]},{"cell_type": "markdown","metadata": {},"source": [- "## Implementation of AnthropicClient\n",- "\n",- "You can find the introduction to Claude-3-Opus model [here](https://docs.anthropic.com/claude/docs/intro-to-claude). \n",- "\n",- "Since anthropic provides their Python SDK with similar structure as OpenAI's, we will following the implementation from `autogen.oai.client.OpenAIClient`.\n",- "\n"+ "### Alternative\n",+ "\n",+ "As an alternative to the api_key key and value in the config, you can set the environment variable `ANTHROPIC_API_KEY` to your Anthropic API key.\n",+ "\n",+ "Linux/Mac:\n",+ "```\n",+ "export ANTHROPIC_API_KEY=\"your Anthropic API key here\"\n",+ "```\n",+ "Windows:\n",+ "```\n",+ "set ANTHROPIC_API_KEY=your_anthropic_api_key_here\n",+ "```"]},{"cell_type": "code",- "execution_count": 11,+ "execution_count": null,"metadata": {},"outputs": [],"source": [- "class AnthropicClient:\n",- " def __init__(self, config: Dict[str, Any]):\n",- " self._config = config\n",- " self.model = config[\"model\"]\n",- " anthropic_kwargs = set(inspect.getfullargspec(Anthropic.__init__).kwonlyargs)\n",- " filter_dict = {k: v for k, v in config.items() if k in anthropic_kwargs}\n",- " self._client = Anthropic(**filter_dict)\n",- "\n",- " self._last_tooluse_status = {}\n",- "\n",- " def message_retrieval(\n",- " self, response: Union[Message, ToolsBetaMessage]\n",- " ) -> Union[List[str], List[ChatCompletionMessage]]:\n",- " \"\"\"Retrieve the messages from the response.\"\"\"\n",- " messages = response.content\n",- " if len(messages) == 0:\n",- " return [None]\n",- " res = []\n",- " if TOOL_ENABLED:\n",- " for choice in messages:\n",- " if choice.type == \"tool_use\":\n",- " res.insert(0, self.response_to_openai_message(choice))\n",- " self._last_tooluse_status[\"tool_use\"] = choice.model_dump()\n",- " else:\n",- " res.append(choice.text)\n",- " self._last_tooluse_status[\"think\"] = choice.text\n",- "\n",- " return res\n",- "\n",- " else:\n",- " return [ # type: ignore [return-value]\n",- " choice.text if choice.message.function_call is not None else choice.message.content # type: ignore [union-attr]\n",- " for choice in messages\n",- " ]\n",- "\n",- " def create(self, params: Dict[str, Any]) -> Completion:\n",- " \"\"\"Create a completion for a given config.\n",- "\n",- " Args:\n",- " params: The params for the completion.\n",- "\n",- " Returns:\n",- " The completion.\n",- " \"\"\"\n",- " if \"tools\" in params:\n",- " converted_functions = self.convert_tools_to_functions(params[\"tools\"])\n",- " params[\"functions\"] = params.get(\"functions\", []) + converted_functions\n",- "\n",- " raw_contents = params[\"messages\"]\n",- " processed_messages = []\n",- " for message in raw_contents:\n",- "\n",- " if message[\"role\"] == \"system\":\n",- " params[\"system\"] = message[\"content\"]\n",- " elif message[\"role\"] == \"function\":\n",- " processed_messages.append(self.return_function_call_result(message[\"content\"]))\n",- " elif \"function_call\" in message:\n",- " processed_messages.append(self.restore_last_tooluse_status())\n",- " elif message[\"content\"] == \"\":\n",- " # I'm not sure how to elegantly terminate the conversation, please give me some advice about this.\n",- " message[\"content\"] = \"I'm done. Please send TERMINATE\"\n",- " processed_messages.append(message)\n",- " else:\n",- " processed_messages.append(message)\n",- "\n",- " params[\"messages\"] = processed_messages\n",- "\n",- " if TOOL_ENABLED and \"functions\" in params:\n",- " completions: Completion = self._client.beta.tools.messages\n",- " else:\n",- " completions: Completion = self._client.messages # type: ignore [attr-defined]\n",- "\n",- " # Not yet support stream\n",- " params = params.copy()\n",- " params[\"stream\"] = False\n",- " params.pop(\"model_client_cls\")\n",- " params[\"max_tokens\"] = params.get(\"max_tokens\", 4096)\n",- " if \"functions\" in params:\n",- " tools_configs = params.pop(\"functions\")\n",- " tools_configs = [self.openai_func_to_anthropic(tool) for tool in tools_configs]\n",- " params[\"tools\"] = tools_configs\n",- " response = completions.create(**params)\n",- "\n",- " return response\n",- "\n",- " def cost(self, response: Completion) -> float:\n",- " \"\"\"Calculate the cost of the response.\"\"\"\n",- " total = 0.0\n",- " tokens = {\n",- " \"input\": response.usage.input_tokens if response.usage is not None else 0,\n",- " \"output\": response.usage.output_tokens if response.usage is not None else 0,\n",- " }\n",- " price_per_million = {\n",- " \"input\": 15,\n",- " \"output\": 75,\n",- " }\n",- " for key, value in tokens.items():\n",- " total += value * price_per_million[key] / 1_000_000\n",- "\n",- " return total\n",- "\n",- " def response_to_openai_message(self, response) -> ChatCompletionMessage:\n",- " dict_response = response.model_dump()\n",- " return ChatCompletionMessage(\n",- " content=None,\n",- " role=\"assistant\",\n",- " function_call={\"name\": dict_response[\"name\"], \"arguments\": json.dumps(dict_response[\"input\"])},\n",- " )\n",- "\n",- " def restore_last_tooluse_status(self) -> Dict:\n",- " cached_content = []\n",- " if \"think\" in self._last_tooluse_status:\n",- " cached_content.append({\"type\": \"text\", \"text\": self._last_tooluse_status[\"think\"]})\n",- " cached_content.append(self._last_tooluse_status[\"tool_use\"])\n",- " res = {\"role\": \"assistant\", \"content\": cached_content}\n",- " return res\n",- "\n",- " def return_function_call_result(self, result: str) -> Dict:\n",- " return {\n",- " \"role\": \"user\",\n",- " \"content\": [\n",- " {\n",- " \"type\": \"tool_result\",\n",- " \"tool_use_id\": self._last_tooluse_status[\"tool_use\"][\"id\"],\n",- " \"content\": result,\n",- " }\n",- " ],\n",- " }\n",- "\n",- " @staticmethod\n",- " def openai_func_to_anthropic(openai_func: dict) -> dict:\n",- " res = openai_func.copy()\n",- " res[\"input_schema\"] = res.pop(\"parameters\")\n",- " return res\n",- "\n",- " @staticmethod\n",- " def get_usage(response: Completion) -> Dict:\n",- " return {\n",- " \"prompt_tokens\": response.usage.input_tokens if response.usage is not None else 0,\n",- " \"completion_tokens\": response.usage.output_tokens if response.usage is not None else 0,\n",- " \"total_tokens\": (\n",- " response.usage.input_tokens + response.usage.output_tokens if response.usage is not None else 0\n",- " ),\n",- " \"cost\": response.cost if hasattr(response, \"cost\") else 0,\n",- " \"model\": response.model,\n",- " }\n",- "\n",- " @staticmethod\n",- " def convert_tools_to_functions(tools: List) -> List:\n",- " functions = []\n",- " for tool in tools:\n",- " if tool.get(\"type\") == \"function\" and \"function\" in tool:\n",- " functions.append(tool[\"function\"])\n",- "\n",- " return functions"- ]- },- {- "cell_type": "markdown",- "metadata": {},- "source": [- "## Set the config for the Anthropic API\n",+ "import os\n","\n",- "You can add any parameters that are needed for the custom model loading in the same configuration list.\n",+ "from typing_extensions import Annotated\n","\n",- "It is important to add the `model_client_cls` field and set it to a string that corresponds to the class name: `\"CustomModelClient\"`."- ]- },- {- "cell_type": "code",- "execution_count": 12,- "metadata": {},- "outputs": [],- "source": [- "import os\n",+ "import autogen\n","\n","config_list_claude = [\n"," {\n",@@ -317,13 +117,18 @@" \"model\": \"claude-3-sonnet-20240229\",\n"," # You need to provide your API key here.\n"," \"api_key\": os.getenv(\"ANTHROPIC_API_KEY\"),\n",- " \"base_url\": \"https://api.anthropic.com\",\n"," \"api_type\": \"anthropic\",\n",- " \"model_client_cls\": \"AnthropicClient\",\n"," }\n","]"]},+ {+ "cell_type": "markdown",+ "metadata": {},+ "source": [+ "# Coding Example with Two Agent"+ ]+ },{"attachments": {},"cell_type": "markdown",@@ -336,26 +141,18 @@},{"cell_type": "code",- "execution_count": 13,+ "execution_count": null,"metadata": {},- "outputs": [- {- "name": "stdout",- "output_type": "stream",- "text": [- "[autogen.oai.client: 04-08 22:15:59] {419} INFO - Detected custom model client in config: AnthropicClient, model client can not be used until register_model_client is called.\n"- ]- }- ],+ "outputs": [],"source": [- "assistant = AssistantAgent(\n",+ "assistant = autogen.AssistantAgent(\n"," \"assistant\",\n"," llm_config={\n"," \"config_list\": config_list_claude,\n"," },\n",")\n","\n",- "user_proxy = UserProxyAgent(\n",+ "user_proxy = autogen.UserProxyAgent(\n"," \"user_proxy\",\n"," human_input_mode=\"NEVER\",\n"," code_execution_config={\n",@@ -371,95 +168,54 @@"cell_type": "markdown","metadata": {},"source": [- "## Function Call in Latest Anthropic API \n",- "Anthropic just announced that tool use is now in public beta in the Anthropic API. To use this feature, please install `anthropic>=0.23.1`."+ "## Initiate Chat"]},{"cell_type": "code",- "execution_count": 14,+ "execution_count": null,"metadata": {},- "outputs": [- {- "name": "stdout",- "output_type": "stream",- "text": [- "[autogen.oai.client: 04-08 22:15:59] {419} INFO - Detected custom model client in config: AnthropicClient, model client can not be used until register_model_client is called.\n"- ]- }- ],+ "outputs": [],"source": [- "@user_proxy.register_for_execution()\n",- "@assistant.register_for_llm(name=\"get_weather\", description=\"Get the current weather in a given location.\")\n",- "def preprocess(location: Annotated[str, \"The city and state, e.g. Toronto, ON.\"]) -> str:\n",- " return \"Absolutely cloudy and rainy\""+ "user_proxy.initiate_chat(\n",+ " assistant, message=\"Write a python program to print the first 10 numbers of the Fibonacci sequence.\"\n",+ ")"]},{"cell_type": "markdown","metadata": {},"source": [- "## Register the custom client class to the assistant agent"+ "# Function Call in Latest Anthropic API \n",+ "Anthropic just announced that tool use is now supported in the Anthropic API. To use this feature, please install `anthropic>=0.23.1`."+ ]+ },+ {+ "cell_type": "markdown",+ "metadata": {},+ "source": [+ "## Register the function"]},{"cell_type": "code",- "execution_count": 15,+ "execution_count": null,"metadata": {},"outputs": [],"source": [- "assistant.register_model_client(model_client_cls=AnthropicClient)"+ "@user_proxy.register_for_execution() # Decorator factory for registering a function to be executed by an agent\n",+ "@assistant.register_for_llm(\n",+ " name=\"get_weather\", description=\"Get the current weather in a given location.\"\n",+ ") # Decorator factory for registering a function to be used by an agent\n",+ "def preprocess(location: Annotated[str, \"The city and state, e.g. Toronto, ON.\"]) -> str:\n",+ " return \"Absolutely cloudy and rainy\""]},{"cell_type": "code",- "execution_count": 16,+ "execution_count": null,"metadata": {},- "outputs": [- {- "name": "stdout",- "output_type": "stream",- "text": [- "user_proxy (to assistant):\n",- "\n",- "What's the weather in Toronto?\n",- "\n",- "--------------------------------------------------------------------------------\n",- "assistant (to user_proxy):\n",- "\n",- "***** Suggested function call: get_weather *****\n",- "Arguments: \n",- "{\"location\": \"Toronto, ON\"}\n",- "************************************************\n",- "\n",- "--------------------------------------------------------------------------------\n",- "\n",- ">>>>>>>> EXECUTING FUNCTION get_weather...\n",- "user_proxy (to assistant):\n",- "\n",- "***** Response from calling function (get_weather) *****\n",- "Absolutely cloudy and rainy\n",- "********************************************************\n",- "\n",- "--------------------------------------------------------------------------------\n",- "assistant (to user_proxy):\n",- "\n",- "The tool returned that the current weather in Toronto, ON is absolutely cloudy and rainy.\n",- "\n",- "--------------------------------------------------------------------------------\n"- ]- },- {- "data": {- "text/plain": [- "ChatResult(chat_id=None, chat_history=[{'content': \"What's the weather in Toronto?\", 'role': 'assistant'}, {'function_call': {'arguments': '{\"location\": \"Toronto, ON\"}', 'name': 'get_weather'}, 'content': None, 'role': 'assistant'}, {'content': 'Absolutely cloudy and rainy', 'name': 'get_weather', 'role': 'function'}, {'content': 'The tool returned that the current weather in Toronto, ON is absolutely cloudy and rainy.', 'role': 'user'}], summary='The tool returned that the current weather in Toronto, ON is absolutely cloudy and rainy.', cost=({'total_cost': 0.030494999999999998, 'claude-3-sonnet-20240229': {'cost': 0.030494999999999998, 'prompt_tokens': 1533, 'completion_tokens': 100, 'total_tokens': 1633}}, {'total_cost': 0}), human_input=[])"- ]- },- "execution_count": 16,- "metadata": {},- "output_type": "execute_result"- }- ],+ "outputs": [],"source": ["user_proxy.initiate_chat(\n"," assistant,\n",@@ -490,7 +246,7 @@"name": "python","nbconvert_exporter": "python","pygments_lexer": "ipython3",- "version": "3.9.7"+ "version": "3.9.13"},"vscode": {"interpreter": {