pip install "camel-ai[all]==0.2.11"
pip install agentops

import os
import agentops
from camel.agents import ChatAgent
from camel.messages import BaseMessage
from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType

# 初始化 AgentOps
agentops.init(os.getenv("AGENTOPS_API_KEY"), tags=["CAMEL 示例"])

# 在 AgentOps 初始化后导入工具包以便跟踪
from camel.toolkits import SearchToolkit

# 设置带有搜索工具的代理
sys_msg = BaseMessage.make_assistant_message(
    role_name='Tools calling operator',
    content='You are a helpful assistant'
)

# 配置工具和模型
tools = [*SearchToolkit().get_tools()]
model = ModelFactory.create(
    model_platform=ModelPlatformType.OPENAI,
    model_type=ModelType.GPT_4O_MINI,
)

# 创建并运行代理
camel_agent = ChatAgent(
    system_message=sys_msg,
    model=model,
    tools=tools,
)

response = camel_agent.step("What is AgentOps?")
print(response)

agentops.end_session("Success")

请查看我们的 Camel 集成指南，了解更多包括多代理场景在内的示例。

pip install agentops[langchain]

要使用该处理器，需导入并设置

import os
from langchain.chat_models import ChatOpenAI
from langchain.agents import initialize_agent, AgentType
from agentops.integration.callbacks.langchain import LangchainCallbackHandler

AGENTOPS_API_KEY = os.environ['AGENTOPS_API_KEY']
handler = LangchainCallbackHandler(api_key=AGENTOPS_API_KEY, tags=['Langchain 示例'])

llm = ChatOpenAI(openai_api_key=OPENAI_API_KEY,
                 callbacks=[handler],
                 model='gpt-3.5-turbo')

agent = initialize_agent(tools,
                         llm,
                         agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,
                         verbose=True,
                         callbacks=[handler], # 必须传递回调处理器才能记录您的代理
                         handle_parsing_errors=True)

请参阅 Langchain 示例笔记本，了解更多包括异步处理器在内的详细信息。

pip install cohere

import cohere
import agentops

# 程序开头代码（如 main.py、__init__.py）
agentops.init(<插入您的 API 密钥>)
co = cohere.Client()

chat = co.chat(
    message="Is it pronounced ceaux-hear or co-hehray?"
)

print(chat)

agentops.end_session('Success')

import cohere
import agentops

# 程序开头代码（如 main.py、__init__.py）
agentops.init(<插入您的 API 密钥>)

co = cohere.Client()

stream = co.chat_stream(
    message="Write me a haiku about the synergies between Cohere and AgentOps"
)

for event in stream:
    if event.event_type == "text-generation":
        print(event.text, end='')

agentops.end_session('Success')

pip install anthropic

import anthropic
import agentops

# 程序代码的开头（即 main.py、__init__.py）
agentops.init(<在此插入您的 API 密钥>)

client = anthropic.Anthropic(
    # 这是默认值，可以省略
    api_key=os.environ.get("ANTHROPIC_API_KEY"),
)

message = client.messages.create(
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "告诉我一个关于 AgentOps 的酷事实",
            }
        ],
        model="claude-3-opus-20240229",
    )
print(message.content)

agentops.end_session('Success')

流式处理

import anthropic
import agentops

# 程序代码的开头（即 main.py、__init__.py）
agentops.init(<在此插入您的 API 密钥>)

client = anthropic.Anthropic(
    # 这是默认值，可以省略
    api_key=os.environ.get("ANTHROPIC_API_KEY"),
)

stream = client.messages.create(
    max_tokens=1024,
    model="claude-3-opus-20240229",
    messages=[
        {
            "role": "user",
            "content": "跟我讲讲流式代理的一些有趣之处吧",
        }
    ],
    stream=True,
)

response = ""
for event in stream:
    if event.type == "content_block_delta":
        response += event.delta.text
    elif event.type == "message_stop":
        print("\n")
        print(response)
        print("\n")

异步

import asyncio
from anthropic import AsyncAnthropic

client = AsyncAnthropic(
    # 这是默认值，可以省略
    api_key=os.environ.get("ANTHROPIC_API_KEY"),
)


async def main() -> None:
    message = await client.messages.create(
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "给我讲讲异步代理的一些有趣之处吧",
            }
        ],
        model="claude-3-opus-20240229",
    )
    print(message.content)


await main()

pip install mistralai

同步

from mistralai import Mistral
import agentops

# 程序代码的开头（即 main.py、__init__.py）
agentops.init(<在此插入您的 API 密钥>)

client = Mistral(
    # 这是默认值，可以省略
    api_key=os.environ.get("MISTRAL_API_KEY"),
)

message = client.chat.complete(
        messages=[
            {
                "role": "user",
                "content": "告诉我一个关于 AgentOps 的酷事实",
            }
        ],
        model="open-mistral-nemo",
    )
print(message.choices[0].message.content)

agentops.end_session('Success')

流式处理

from mistralai import Mistral
import agentops

# 程序代码的开头（即 main.py、__init__.py）
agentops.init(<在此插入您的 API 密钥>)

client = Mistral(
    # 这是默认值，可以省略
    api_key=os.environ.get("MISTRAL_API_KEY"),
)

message = client.chat.stream(
        messages=[
            {
                "role": "user",
                "content": "跟我讲讲流式代理的一些有趣之处吧",
            }
        ],
        model="open-mistral-nemo",
    )

response = ""
for event in message:
    if event.data.choices[0].finish_reason == "stop":
        print("\n")
        print(response)
        print("\n")
    else:
        response += event.text

agentops.end_session('Success')

异步

import asyncio
from mistralai import Mistral

client = Mistral(
    # 这是默认值，可以省略
    api_key=os.environ.get("MISTRAL_API_KEY"),
)


async def main() -> None:
    message = await client.chat.complete_async(
        messages=[
            {
                "role": "user",
                "content": "跟我讲讲异步代理的一些有趣之处吧",
            }
        ],
        model="open-mistral-nemo",
    )
    print(message.choices[0].message的内容)


await main()

异步流式处理

import asyncio
from mistralai import Mistral

client = Mistral(
    # 这是默认值，可以省略
    api_key=os.environ.get("MISTRAL_API_KEY"),
)


async def main() -> None:
    message = await client.chat.stream_async(
        messages=[
            {
                "role": "user",
                "content": "跟我讲讲异步流式代理的一些有趣之处吧",
            }
        ],
        model="open-mistral-nemo",
    )

    response = ""
    async for event in message:
        if event.data.choices[0].finish_reason == "stop":
            print("\n")
            print(response)
            print("\n")
        else:
            response += event.text


await main()

pip install camel-ai[all]
pip install agentops

# 导入依赖
import agentops
import os
from getpass import getpass
from dotenv import load_dotenv

# 设置密钥
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY") 或 "<您在这里填写 OpenAI 密钥>"
agentops_api_key = os.getenv("AGENTOPS_API_KEY") 或 "<您在这里填写 AgentOps 密钥>"

pip install litellm

# 不要这样使用 LiteLLM
# from litellm import completion
# ...
# response = completion(model="claude-3", messages=messages)

# 应该这样使用 LiteLLM
import litellm
...
response = litellm.completion(model="claude-3", messages=messages)
# 或者
response = await litellm.acompletion(model="claude-3", messages=messages)

pip install llama-index-instrumentation-agentops

要使用该处理器，请导入并设置：

from llama_index.core import set_global_handler

# 注意：您可以根据 AgentOps 文档中的说明设置您的 AgentOps 环境变量（例如 'AGENTOPS_API_KEY'），或者在 set_global_handler 中将 AgentOps 的 AOClient 所需的等效关键字参数作为 **eval_params 传递。
set_global_handler("agentops")

更多详细信息请参阅 LlamaIndex 文档。

pip install swarmzero
pip install agentops

from dotenv import load_dotenv
load_dotenv()

import agentops
agentops.init(<在此处插入您的 API 密钥>)

from swarmzero import Agent, Swarm
# ...