OASIS Documentation

To run a Twitter simulation, you need to set up a model manager (using a round-robin strategy for multiple models), define available actions using ActionType.get_default_twitter_actions(), and generate an agent graph using generate_twitter_agent_graph. You must also specify a database path via the OASIS_DB_PATH environment variable or the database_path parameter in oasis.make().

Steps:

1. Deploy a vLLM server.
2. Create models using ModelFactory.
3. Initialize a ModelManager with a scheduling_strategy (e.g., 'round_robin').
4. Generate the agent graph with generate_twitter_agent_graph.
5. Create the environment with oasis.make() using oasis.DefaultPlatformType.TWITTER.
6. Use env.reset() to start and env.step(actions) to progress the simulation.

import asyncio
import os
from camel.models import ModelFactory, ModelManager
from camel.types import ModelPlatformType
import oasis
from oasis import (ActionType, LLMAction, ManualAction,
                   generate_twitter_agent_graph)

async def main():
    # 1. Setup Models
    vllm_model_1 = ModelFactory.create(
        model_platform=ModelPlatformType.VLLM,
        model_type="qwen-2",
        url="http://your-vllm-url:8080/v1",
    )
    vllm_model_2 = ModelFactory.create(
        model_platform=ModelPlatformType.VLLM,
        model_type="qwen-2",
        url="http://your-vllm-url:8080/v1",
    )

    shared_model_manager = ModelManager(
        models=[vllm_model_1, vllm_model_2],
        scheduling_strategy='round_robin',
    )

    # 2. Define Actions and Graph
    available_actions = ActionType.get_default_twitter_actions()
    agent_graph = await generate_twitter_agent_graph(
        profile_path="data/twitter_dataset/your_dataset.csv",
        model=shared_model_manager,
        available_actions=available_actions,
    )

    # 3. Setup Environment
    db_path = "./data/twitter_simulation.db"
    os.environ["OASIS_DB_PATH"] = os.path.abspath(db_path)
    
    env = oasis.make(
        agent_graph=agent_graph,
        platform=oasis.DefaultPlatformType.TWITTER,
        database_path=db_path,
    )

    # 4. Run Simulation
    await env.reset()

    # Example: Manual action for one agent
    actions_1 = {
        env.agent_graph.get_agent(0): ManualAction(
            action_type=ActionType.CREATE_POST,
            action_args={"content": "Earth is flat."}
        )
    }
    await env.step(actions_1)

    # Example: LLM actions for specific agents
    actions_2 = {
        agent: LLMAction()
        for _, agent in env.agent_graph.get_agents([1, 3, 5, 7, 9])
    }
    await env.step(actions_2)

    await env.close()

if __name__ == "__main__":
    asyncio.run(main())

To run a simulation, you need to:

1. Prepare an agent profile JSON file (e.g., user_data_36.json).
2. Define the LLM model using ModelFactory.
3. Define available_actions using ActionType.
4. Generate an agent graph using generate_reddit_agent_graph.
5. Create the environment using oasis.make.
6. Execute steps using env.step() with either ManualAction or LLMAction.

import asyncio
import os

from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType

import oasis
from oasis import (ActionType, LLMAction, ManualAction,
                   generate_reddit_agent_graph)


async def main():
    # Define the model for the agents
    openai_model = ModelFactory.create(
        model_platform=ModelPlatformType.OPENAI,
        model_type=ModelType.GPT_4O_MINI,
    )

    # Define the available actions for the agents
    available_actions = [
        ActionType.LIKE_POST,
        ActionType.DISLIKE_POST,
        ActionType.CREATE_POST,
        ActionType.CREATE_COMMENT,
        ActionType.LIKE_COMMENT,
        ActionType.DISLIKE_COMMENT,
        ActionType.SEARCH_POSTS,
        ActionType.SEARCH_USER,
        ActionType.TREND,
        ActionType.REFRESH,
        ActionType.DO_NOTHING,
        ActionType.FOLLOW,
        ActionType.MUTE,
    ]

    agent_graph = await generate_reddit_agent_graph(
        profile_path="./data/reddit/user_data_36.json",
        model=openai_model,
        available_actions=available_actions,
    )

    # Define the path to the database
    db_path = "./data/reddit_simulation.db"

    # Delete the old database
    if os.path.exists(db_path):
        os.remove(db_path)

    # Make the environment
    env = oasis.make(
        agent_graph=agent_graph,
        platform=oasis.DefaultPlatformType.REDDIT,
        database_path=db_path,
    )

    # Run the environment
    await env.reset()

    actions_1 = {}
    actions_1[env.agent_graph.get_agent(0)] = [
        ManualAction(action_type=ActionType.CREATE_POST,
                     action_args={"content": "Hello, world!"}),
        ManualAction(action_type=ActionType.CREATE_COMMENT,
                     action_args={
                         "post_id": "1",
                         "content": "Welcome to the OASIS World!"
                     })
    ]
    actions_1[env.agent_graph.get_agent(1)] = ManualAction(
        action_type=ActionType.CREATE_COMMENT,
        action_args={
            "post_id": "1",
            "content": "I like the OASIS world."
        })
    await env.step(actions_1)

    actions_2 = {
        agent: LLMAction()
        for _, agent in env.agent_graph.get_agents()
    }

    # Perform the actions
    await env.step(actions_2)

    # Close the environment
    await env.close()


if __name__ == "__main__":
    asyncio.run(main())

To enable post reporting in your simulation, you must include ActionType.REPORT_POST in the available_actions list when calling generate_twitter_agent_graph.

Once enabled, you can trigger a report using ManualAction with the following arguments:

• post_id: The ID of the post being reported.
• report_reason: A string describing why the post is being reported.

Reports can be submitted individually or by multiple agents within the same env.step() call, and they can be mixed with other social media actions like CREATE_POST or LIKE_POST.

# 1. Enable the action in the graph creation
available_actions = [
    ActionType.CREATE_POST,
    ActionType.LIKE_POST,
    ActionType.REPORT_POST,  # Required for reporting functionality
    ActionType.REPOST,
    ActionType.FOLLOW,
    ActionType.DO_NOTHING,
]

agent_graph = await generate_twitter_agent_graph(
    profile_path="path/to/dataset.csv",
    model=openai_model,
    available_actions=available_actions,
)

# 2. Execute a report action
report_action = ManualAction(
    action_type=ActionType.REPORT_POST,
    action_args={
        "post_id": 1,
        "report_reason": "This is inappropriate content"
    }
)

actions = {env.agent_graph.get_agent(0): report_action}
await env.step(actions)