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
# Initialize AgentOps
agentops.init(os.getenv("AGENTOPS_API_KEY"), tags=["CAMEL Example"])
# Import toolkits after AgentOps init for tracking
from camel.toolkits import SearchToolkit
# Set up the agent with search tools
sys_msg = BaseMessage.make_assistant_message(
 role_name='Tools calling operator',
 content='You are a helpful assistant'
)
# Configure tools and model
tools = [*SearchToolkit().get_tools()]
model = ModelFactory.create(
 model_platform=ModelPlatformType.OPENAI,
 model_type=ModelType.GPT_4O_MINI,
)
# Create and run the agent
camel_agent = ChatAgent(
 system_message=sys_msg,
 model=model,
 tools=tools,
)
response = camel_agent.step("What is AgentOps?")
print(response)
agentops.end_session("Success")

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 Example'])
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], # You must pass in a callback handler to record your agent
 handle_parsing_errors=True)

pip install cohere

import cohere
import agentops
# Beginning of program's code (i.e. main.py, __init__.py)
agentops.init(<INSERT YOUR API KEY HERE>)
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
# Beginning of program's code (i.e. main.py, __init__.py)
agentops.init(<INSERT YOUR API KEY HERE>)
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
# Beginning of program's code (i.e. main.py, __init__.py)
agentops.init(<INSERT YOUR API KEY HERE>)
client = anthropic.Anthropic(
 # This is the default and can be omitted
 api_key=os.environ.get("ANTHROPIC_API_KEY"),
)
message = client.messages.create(
 max_tokens=1024,
 messages=[
 {
 "role": "user",
 "content": "Tell me a cool fact about AgentOps",
 }
 ],
 model="claude-3-opus-20240229",
 )
print(message.content)
agentops.end_session('Success')

import anthropic
import agentops
# Beginning of program's code (i.e. main.py, __init__.py)
agentops.init(<INSERT YOUR API KEY HERE>)
client = anthropic.Anthropic(
 # This is the default and can be omitted
 api_key=os.environ.get("ANTHROPIC_API_KEY"),
)
stream = client.messages.create(
 max_tokens=1024,
 model="claude-3-opus-20240229",
 messages=[
 {
 "role": "user",
 "content": "Tell me something cool about streaming agents",
 }
 ],
 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(
 # This is the default and can be omitted
 api_key=os.environ.get("ANTHROPIC_API_KEY"),
)
async def main() -> None:
 message = await client.messages.create(
 max_tokens=1024,
 messages=[
 {
 "role": "user",
 "content": "Tell me something interesting about async agents",
 }
 ],
 model="claude-3-opus-20240229",
 )
 print(message.content)
await main()

pip install mistralai

from mistralai import Mistral
import agentops
# Beginning of program's code (i.e. main.py, __init__.py)
agentops.init(<INSERT YOUR API KEY HERE>)
client = Mistral(
 # This is the default and can be omitted
 api_key=os.environ.get("MISTRAL_API_KEY"),
)
message = client.chat.complete(
 messages=[
 {
 "role": "user",
 "content": "Tell me a cool fact about AgentOps",
 }
 ],
 model="open-mistral-nemo",
 )
print(message.choices[0].message.content)
agentops.end_session('Success')

from mistralai import Mistral
import agentops
# Beginning of program's code (i.e. main.py, __init__.py)
agentops.init(<INSERT YOUR API KEY HERE>)
client = Mistral(
 # This is the default and can be omitted
 api_key=os.environ.get("MISTRAL_API_KEY"),
)
message = client.chat.stream(
 messages=[
 {
 "role": "user",
 "content": "Tell me something cool about streaming agents",
 }
 ],
 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(
 # This is the default and can be omitted
 api_key=os.environ.get("MISTRAL_API_KEY"),
)
async def main() -> None:
 message = await client.chat.complete_async(
 messages=[
 {
 "role": "user",
 "content": "Tell me something interesting about async agents",
 }
 ],
 model="open-mistral-nemo",
 )
 print(message.choices[0].message.content)
await main()

import asyncio
from mistralai import Mistral
client = Mistral(
 # This is the default and can be omitted
 api_key=os.environ.get("MISTRAL_API_KEY"),
)
async def main() -> None:
 message = await client.chat.stream_async(
 messages=[
 {
 "role": "user",
 "content": "Tell me something interesting about async streaming agents",
 }
 ],
 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 Dependencies
import agentops
import os
from getpass import getpass
from dotenv import load_dotenv
#Set Keys
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY") or "<your openai key here>"
agentops_api_key = os.getenv("AGENTOPS_API_KEY") or "<your agentops key here>"

pip install litellm

# Do not use LiteLLM like this
# from litellm import completion
# ...
# response = completion(model="claude-3", messages=messages)
# Use LiteLLM like this
import litellm
...
response = litellm.completion(model="claude-3", messages=messages)
# or
response = await litellm.acompletion(model="claude-3", messages=messages)

pip install llama-index-instrumentation-agentops

from llama_index.core import set_global_handler
# NOTE: Feel free to set your AgentOps environment variables (e.g., 'AGENTOPS_API_KEY')
# as outlined in the AgentOps documentation, or pass the equivalent keyword arguments
# anticipated by AgentOps' AOClient as **eval_params in set_global_handler.
set_global_handler("agentops")

pip install swarmzero
pip install agentops

from dotenv import load_dotenv
load_dotenv()
import agentops
agentops.init(<INSERT YOUR API KEY HERE>)
from swarmzero import Agent, Swarm
# ...