Master CAMEL-AI

# Basic installation
pip install camel-ai

# Full installation with all dependencies
pip install 'camel-ai[all]'

# Setting up API keys
import os

# For OpenAI models
os.environ["OPENAI_API_KEY"] = "your-api-key-here"

# Using .env file
from dotenv import load_dotenv
load_dotenv()  # Loads variables from .env file

# Simple agent creation
from camel.agents import ChatAgent
from camel.models import ModelFactory

agent = ChatAgent(
    system_message="You are a helpful assistant.",
    model=ModelFactory.create()
)

# Agent with specific role using BaseMessage
from camel.messages import BaseMessage

role_agent = ChatAgent(
    BaseMessage.make_assistant_message(
        role_name="Marketing Specialist",
        content="You are an expert in digital marketing strategies."
    ),
    model=ModelFactory.create()
)

# Agent with custom model
from camel.types import ModelPlatformType, ModelType

custom_model_agent = ChatAgent(
    system_message="You are a technical writer specializing in documentation.",
    model=ModelFactory.create(
        model_platform=ModelPlatformType.OPENAI,
        model_type=ModelType.GPT_4O_MINI,
    )
)

# Interacting with an agent
response = agent.step("Tell me about machine learning.")
print(response.msgs[0].content)  # Access the response content

# Adding tools to an agent
from camel.toolkits import MathToolkit, SearchToolkit, GoogleMapsToolkit

# Agent with math tools
math_agent = ChatAgent(
    system_message="You are a math assistant.",
    model=ModelFactory.create(),
    tools=MathToolkit().get_tools()
)

# Agent with search capabilities
search_agent = ChatAgent(
    system_message="You are a research assistant.",
    model=ModelFactory.create(),
    tools=SearchToolkit().get_tools()
)

# Agent with multiple tool types
multi_tool_agent = ChatAgent(
    system_message="You are an assistant with multiple capabilities.",
    model=ModelFactory.create(),
    tools=[
        *MathToolkit().get_tools(),
        *SearchToolkit().get_tools(),
        *GoogleMapsToolkit().get_tools()
    ]
)

# Checking tool calls in response
response = search_agent.step("Who won the Nobel Prize in Physics in 2023?")
print(response.info['tool_calls'])  # See which tools were called

# Creating an agent with custom memory window
memory_agent = ChatAgent(
    system_message="You are an assistant with enhanced memory.",
    model=ModelFactory.create(),
    message_window_size=20  # Remember more context
)

# Accessing agent memory
context = memory_agent.memory.get_context()
print(context)  # Shows current memory contents

# Adding a message to memory
from camel.messages import BaseMessage

new_message = BaseMessage.make_user_message(
    content="Remember this important fact for later reference."
)
memory_agent.record_message(new_message)

# Clearing agent memory
memory_agent.memory.clear()

# Setting up external memory (conceptual example)
from camel.memory import VectorDBMemory

external_memory = VectorDBMemory(
    connection_string="your-vector-db-connection",
    embedding_model="text-embedding-ada-002"
)

agent_with_external_memory = ChatAgent(
    system_message="You have access to long-term memory.",
    model=ModelFactory.create(),
    memory=external_memory
)

# Setting up a multi-agent workforce
from camel.societies.workforce import Workforce
from camel.tasks.task import Task

# Create individual agents
agent1 = ChatAgent(
    system_message="You are a research specialist.",
    model=ModelFactory.create(),
    tools=SearchToolkit().get_tools()
)

agent2 = ChatAgent(
    system_message="You analyze information and extract insights.",
    model=ModelFactory.create()
)

agent3 = ChatAgent(
    system_message="You create well-structured reports.",
    model=ModelFactory.create()
)

# Create the workforce
team = Workforce('Research Team')
team.add_single_agent_worker("Researcher", worker=agent1)
team.add_single_agent_worker("Analyst", worker=agent2)
team.add_single_agent_worker("Writer", worker=agent3)

# Define and process a task
research_task = Task(
    content="Create a comprehensive report on quantum computing advancements in 2024.",
    id='research_001',
)
result = team.process_task(research_task)
print(result.result)  # Final output from all agents

# Setting up RAG with CAMEL-AI (conceptual example)
from camel.agents import ChatAgent
from camel.retrievers import VectorDBRetriever
from camel.models import ModelFactory

# Set up a retriever with vector database
retriever = VectorDBRetriever(
    database_url="your-vector-db-connection",
    embedding_model="text-embedding-ada-002",
    similarity_top_k=3  # Number of documents to retrieve
)

# Create a RAG agent
rag_agent = ChatAgent(
    system_message="You are a knowledge assistant that uses a database to answer questions accurately.",
    model=ModelFactory.create(),
    retriever=retriever,
)

# Query the agent (will automatically retrieve relevant information)
response = rag_agent.step("What are the key benefits of quantum computing for cryptography?")
print(response.msgs[0].content)

# Generating synthetic conversation data
from camel.agents import ChatAgent
from camel.messages import BaseMessage
from camel.models import ModelFactory

# Create role-playing agents
customer_agent = ChatAgent(
    BaseMessage.make_assistant_message(
        role_name="Customer",
        content="You are a customer contacting support about a recent purchase."
    ),
    model=ModelFactory.create(),
)

support_agent = ChatAgent(
    BaseMessage.make_assistant_message(
        role_name="Support Agent",
        content="You are a helpful customer support representative."
    ),
    model=ModelFactory.create(),
)

# Generate conversation
conversations = []
initial_query = "I recently purchased your product but it's not working as expected."

# Conversation loop
customer_msg = BaseMessage.make_user_message(content=initial_query)
for i in range(5):  # 5 turns of conversation
    support_response = support_agent.step(customer_msg.content)
    conversations.append({"role": "customer", "message": customer_msg.content})
    conversations.append({"role": "support", "message": support_response.msgs[0].content})

    if i < 4:  # Skip last customer turn
        customer_msg = customer_agent.step(support_response.msgs[0].content)

# Save synthetic data
import json
with open("synthetic_conversations.json", "w") as f:
    json.dump(conversations, f, indent=2)