Anthropic - AG2

Anthropic

Anthropic's 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.

In this notebook, we demonstrate how to use Anthropic Claude model for AgentChat in AG2.

Features

Requirements

To use Anthropic Claude with AG2, first you need to install the ag2[anthropic] package.

To try out the function call feature of Claude model, you need to install anthropic>=0.23.1.

# If you need to install AG2 with Anthropic
pip install ag2[anthropic]

Tip

If you have been using autogen or pyautogen, all you need to do is upgrade it using:

pip install -U autogen[anthropic]

or

pip install -U pyautogen[anthropic]

as pyautogen, autogen, and ag2 are aliases for the same PyPI package.

Set the config for the Anthropic API

You can add any parameters that are needed for the custom model loading in the same configuration list.

It is important to add the api_type field and set it to a string that corresponds to the client type used: anthropic.

Example:

[
    {
        "model": "claude-3-5-sonnet-20240620",
        "api_key": "your api key",
        "api_type": "anthropic"
    },
    {
        "model": "claude-3-7-sonnet-20250219",
        "api_key": "your api key",
        "api_type": "anthropic",
        "max_tokens": 8192, # override the default value of 4096, max tokens must be greater than thinking budget
        "timeout": 600, # for larger thinking budgets, increase the timeout OR enable streaming
        "thinking": {"type": "enabled", "budget_tokens": 2048}
    }
]

Alternative

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.

Linux/Mac:

export ANTHROPIC_API_KEY="your Anthropic API key here"

Windows:

set ANTHROPIC_API_KEY=your_anthropic_api_key_here

import os
from typing_extensions import Annotated
import autogen

llm_config_claude = autogen.LLMConfig(
    model="claude-3-5-sonnet-20240620",
    api_key=os.getenv("ANTHROPIC_API_KEY"),
    api_type="anthropic",
)

Alternative Anthropic VertexAI Client (GCP)

To use the Anthropic VertexAI client in AG2, you need to configure it for use with Google Cloud Platform (GCP). Ensure you have the necessary project credentials and install the required package.

Configuration The following configuration example demonstrates how to set up Anthropic VertexAI:

import os

llm_config_vertexai = LLMConfig(
    model="claude-3-5-sonnet-20240620-v1:0",
    gcp_project_id="your_project_id",
    gcp_region="us-west-2",  # Replace with your GCP region
    gcp_auth_token=None,  # Optional: If not passed, Google Default Authentication will be used
    api_type="anthropic",
)

with llm_config_vertexai:
    assistant = autogen.AssistantAgent("assistant")

Two-agent Coding Example

Construct a simple conversation between a User proxy and a ConversableAgent based on Claude-3 model.

with llm_config_claude:
    assistant = autogen.AssistantAgent("assistant")

user_proxy = autogen.UserProxyAgent(
    "user_proxy",
    human_input_mode="NEVER",
    code_execution_config={
        "work_dir": "coding",
        "use_docker": False,
    },
    is_termination_msg=lambda x: x.get("content", "") and x.get("content", "").rstrip().endswith("TERMINATE"),
    max_consecutive_auto_reply=1,
)

user_proxy.initiate_chat(
    assistant, message="Write a python program to print the first 10 numbers of the Fibonacci sequence."
)

user_proxy (to assistant):

Write a python program to print the first 10 numbers of the Fibonacci sequence.

o--------------------------------------------------------------------------------

assistant (to user_proxy):

Certainly! I'll write a Python program to print the first 10 numbers of the Fibonacci sequence. Here's the code:

```python
# filename: fibonacci.py

def fibonacci(n):
    fib_sequence = [0, 1]

while len(fib_sequence) < n:
        next_number = fib_sequence[-1] + fib_sequence[-2]
        fib_sequence.append(next_number)

return fib_sequence

# Print the first 10 numbers of the Fibonacci sequence
n = 10
result = fibonacci(n)
print(f"The first {n} numbers of the Fibonacci sequence are:")
print(result)

This program does the following:

  1. We define a function called fibonacci that takes an argument n, which is the number of Fibonacci numbers we want to generate.
  2. We initialize the fib_sequence list with the first two numbers of the Fibonacci sequence: 0 and 1.
  3. We use a while loop to generate subsequent numbers in the sequence by adding the last two numbers until we have n numbers in the sequence.
  4. We return the complete Fibonacci sequence.
  5. Outside the function, we set n = 10 to get the first 10 numbers.
  6. We call the fibonacci function with n = 10 and store the result in the result variable.
  7. Finally, we print the result.

Let's run this code and see the output. The code will be saved in a file named "fibonacci.py". You can execute it using Python.

o--------------------------------------------------------------------------------

Tool Call Example with the Latest Anthropic API

Anthropic announced that tool use is supported in the Anthropic API. To use this feature, please install anthropic>=0.23.1.

Register the function

@user_proxy.register_for_execution()  # Decorator factory for registering a function to be executed by an agent
@assistant.register_for_llm(
    name="get_weather", description="Get the current weather in a given location."
)  # Decorator factory for registering a function to be used by an agent

def preprocess(location: Annotated[str, "The city and state, e.g. Toronto, ON."]) -> str:
    return "Absolutely cloudy and rainy"

user_proxy.initiate_chat(
    assistant,
    message="What's the weather in Toronto?",
)

user_proxy (to assistant):

What's the weather in Toronto?

o--------------------------------------------------------------------------------

assistant (to user_proxy):

To get the weather in Toronto, we can use the available `get_weather` function. Let's call it to retrieve the current weather information for Toronto.
***** Suggested tool call (toolu_01KFiJWsMwTbcWerTHCgytuX): get_weather *****
Arguments:
{"location": "Toronto, ON"}
********************************************************************************

-------------

## Group Chat Example with both Claude and GPT Agents
### A group chat with GPT-4 as the judge
```python
from autogen import AssistantAgent, GroupChat, GroupChatManager, UserProxyAgent, LLMConfig

llm_config_gpt4 = autogen.LLMConfig(
    model="gpt-4",
    api_key=os.getenv("OPENAI_API_KEY"),
    api_type="openai",
)

with llm_config_gpt4:
    alice = AssistantAgent(
        "Openai_agent",
        system_message="You are from OpenAI. You make arguments to support your company's position.",
    )

dan = AssistantAgent(
        "Judge",
        system_message="You are a judge. You will evaluate the arguments and make a decision on which one is more convincing.",
    )

with llm_config_claude:
    bob = autogen.AssistantAgent(
        "Anthropic_agent",
        system_message="You are from Anthropic. You make arguments to support your company's position.",
    )

with llm_config_gpt35:
    charlie = AssistantAgent(
        "Research_Assistant",
        system_message="You are a helpful assistant to research the latest news and headlines.",
    )

code_interpreter = UserProxyAgent(
    "code-interpreter",
    human_input_mode="NEVER",
    code_execution_config={
        "work_dir": "coding",
        "use_docker": False,
    },
    default_auto_reply="",
    is_termination_msg=lambda x: x.get("content", "").find("TERMINATE") >= 0,
)

@code_interpreter.register_for_execution()  # Decorator factory for registering a function to be executed by an agent
@charlie.register_for_llm(
    name="get_headlines", description="Get the headline of a particular day."
)  # Decorator factory for registering a function to be used by an agent

def get_headlines(headline_date: Annotated[str, "Date in MMDDYY format, e.g., 06192024"]) -> str:
    mock_news = {
        "06202024": "OpenAI competitor Anthropic announces its most powerful AI yet.",
        "06192024": "OpenAI founder Sutskever sets up new AI company devoted to safe superintelligence.",
    }
    return mock_news.get(headline_date, "No news available for today.")

groupchat = GroupChat(
    agents=[alice, bob, charlie, dan, code_interpreter],
    messages=[],
    allow_repeat_speaker=False,
    max_round=10,
)

manager = GroupChatManager(
    groupchat=groupchat,
    llm_config=llm_config_gpt4,
)

user_proxy.initiate_chat(manager, message="Analyze the potential of OpenAI and Anthropic to revolutionize the field of AI based on today's headlines. Today is 06202024.")

user_proxy (to chat_manager):

Analyze the potential of OpenAI and Anthropic to revolutionize the field of AI based on today's headlines. Today is 06202024.

Thinking Mode

You can utilize Anthropic's thinking mode by setting it in the configuration.

from autogen import ConversableAgent

# Here we configure the thinking mode and the token budget for thinking
llm_config = {
    "config_list": [
        {
            "model": "claude-3-7-sonnet-20250219",
            "api_type": "anthropic",
            "max_tokens": 8192,
            "timeout": 600,
            "thinking": {"type": "enabled", "budget_tokens": 2048},
        }
    ],
}

dagent = ConversableAgent(
    name="test",
    llm_config=llm_config,
)

# Create the run
response = agent.run(
    message="Please provide a comparison of JS and TS",
    user_input=False,
    max_turns=1,
)

# Process the run
response.process()

# Print out the final response (thinking tokens are not shown)
print(response.summary)