CAMEL - Build Multi-Agent AI Systems

In CAMEL, every model refers specifically to a Large Language Model (LLM) the intelligent core powering your agent’s understanding, reasoning, and conversational capabilities.

Play with different models in our interactive Colab Notebook.

Large Language Models (LLMs)

LLMs are sophisticated AI systems trained on vast datasets to understand and generate human-like text. They reason, summarize, create content, and drive conversations effortlessly.

Flexible Model Integration

CAMEL allows quick integration and swapping of leading LLMs from providers like OpenAI, Gemini, Llama, Anthropic, Nebius, and more, helping you match the best model to your task.

Optimized for Customization

Customize performance parameters such as temperature, token limits, and response structures easily, balancing creativity, accuracy, and efficiency.

Rapid Experimentation

Experiment freely, CAMEL’s modular design lets you seamlessly compare and benchmark different LLMs, adapting swiftly as your project needs evolve.

Supported Model Platforms in CAMEL

CAMEL supports a wide range of models, including OpenAI’s GPT series, Meta’s Llama models, DeepSeek models (R1 and other variants), and more.

Direct Integrations

Model Provider	Model Type(s)
OpenAI	gpt-4.5-preview gpt-4o, gpt-4o-mini o1, o1-preview, o1-mini o3-mini, o3-pro, o3 o4-mini gpt-4.1, gpt-4.1-mini, gpt-4.1-nano gpt-5, gpt-5-mini, gpt-5-nano gpt-4-turbo, gpt-4, gpt-3.5-turbo
Azure OpenAI	gpt-4o, gpt-4-turbo gpt-4, gpt-3.5-turbo
Mistral AI	mistral-large-latest, pixtral-12b-2409 ministral-8b-latest, ministral-3b-latest open-mistral-nemo, codestral-latest open-mistral-7b, open-mixtral-8x7b open-mixtral-8x22b, open-codestral-mamba mistral-small-2506, mistral-medium-2508 magistral-small-1.2, magistral-medium-1.2
Moonshot	moonshot-v1-8k moonshot-v1-32k moonshot-v1-128k
Anthropic	claude-3-7-sonnet-latest claude-sonnet-4-5, claude-opus-4-5, claude-haiku-4-5 claude-sonnet-4-20250514, claude-opus-4-20250514, claude-opus-4-1-20250805
Gemini	gemini-3-pro-preview, gemini-3-flash-preview gemini-2.5-pro, gemini-2.5-flash gemini-2.0-flash, gemini-2.0-flash-thinking-exp gemini-2.0-flash-lite
Lingyiwanwu	yi-lightning, yi-large, yi-medium yi-large-turbo, yi-vision, yi-medium-200k yi-spark, yi-large-rag, yi-large-fc
Qwen	qwen3-coder-plus, qwq-32b-preview, qwq-plus, qvq-72b-preview, qwen-max, qwen-plus, qwen-turbo, qwen-long qwen-plus-latest, qwen-plus-2025-04-28, qwen-turbo-latest, qwen-turbo-2025-04-28 qwen-vl-max, qwen-vl-plus, qwen-vl-72b-instruct, qwen-math-plus, qwen-math-turbo, qwen-coder-turbo qwen2.5-coder-32b-instruct, qwen2.5-72b-instruct, qwen2.5-32b-instruct, qwen2.5-14b-instruct
DeepSeek	deepseek-chat deepseek-reasoner
CometAPI	All models available on CometAPI Including: gpt-5-chat-latest, gpt-5, gpt-5-mini, gpt-5-nano claude-opus-4-1-20250805, claude-sonnet-4-20250514, claude-3-7-sonnet-latest gemini-2.5-pro, gemini-2.5-flash, grok-4-0709, grok-3 deepseek-v3.1, deepseek-v3, deepseek-r1-0528, qwen3-30b-a3b
Nebius	All models available on Nebius AI Studio Including: gpt-oss-120b, gpt-oss-20b, GLM-4.5 DeepSeek V3 & R1, LLaMA, Mistral, and more
ZhipuAI	glm-4.7, glm-4.7-flash, glm-4.7-flashx glm-4.6, glm-4.6v, glm-4.6v-flash glm-4, glm-4v, glm-4v-flash glm-4v-plus-0111, glm-4-plus, glm-4-air glm-4-air-0111, glm-4-airx, glm-4-long glm-4-flashx, glm-4-flashx-250414 glm-4-flash, glm-4-flash-250414 glm-4.5-air, glm-4.5-airx, glm-4.5-flash glm-4.1v-thinking-flash, glm-4.1v-thinking-flashx glm-zero-preview, glm-3-turbo
InternLM	internlm3-latest, internlm3-8b-instruct internlm2.5-latest, internlm2-pro-chat
Reka	reka-core, reka-flash, reka-edge
COHERE	command-r-plus, command-r, command-light, command, command-nightly
ERNIE	ernie-x1-turbo-32k, ernie-x1-32k, ernie-x1-32k-preview ernie-4.5-turbo-128k, ernie-4.5-turbo-32k deepseek-v3, deepseek-r1, qwen3-235b-a22b
MiniMax	MiniMax-M2, MiniMax-M2-Stable
AtlasCloud	openai/gpt-oss-120b, zai-org/glm-4-7

API & Connector Platforms

Model Platform	Supported via API/Connector
GROQ	supported models
TOGETHER AI	supported models
SambaNova	supported models
Ollama	supported models
OpenRouter	supported models
PPIO	supported models
LiteLLM	supported models
LMStudio	supported models
vLLM	supported models
SGLANG	supported models
NetMind	supported models
NOVITA	supported models
NVIDIA	supported models
AIML	supported models
ModelScope	supported models
AWS Bedrock	supported models
IBM WatsonX	supported models
Crynux	supported models
SiliconFlow	supported models
AMD	dvue-aoai-001-gpt-4.1
Volcano	supported models
Qianfan	supported models

How to Use Models via API Calls

Integrate your favorite models into CAMEL-AI with straightforward Python calls. Choose a provider below to see how it’s done:

Here’s how you use OpenAI models such as GPT-4o-mini with CAMEL:

from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
from camel.configs import ChatGPTConfig
from camel.agents import ChatAgent

model = ModelFactory.create(
    model_platform=ModelPlatformType.OPENAI,
    model_type=ModelType.GPT_4O_MINI,
    model_config_dict=ChatGPTConfig(temperature=0.2).as_dict(),
)

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

response = agent.step("Say hi to CAMEL AI community.")
print(response.msg.content)

Using Google’s Gemini models in CAMEL:

Google AI Studio (Quick Start): Try models quickly in a no-code environment.
API Key Setup (Generate Key): Obtain your Gemini API key to start integration.
Gemini API Docs (Deep Dive): Explore detailed Gemini API capabilities.

from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
from camel.configs import GeminiConfig
from camel.agents import ChatAgent

model = ModelFactory.create(
    model_platform=ModelPlatformType.GEMINI,
    model_type=ModelType.GEMINI_2_5_PRO,
    model_config_dict=GeminiConfig(temperature=0.2).as_dict(),
)

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

response = agent.step("Say hi to CAMEL AI community.")
print(response.msgs[0].content)

Integrate Mistral AI models like Mistral Medium into CAMEL:

from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
from camel.configs import MistralConfig
from camel.agents import ChatAgent

model = ModelFactory.create(
    model_platform=ModelPlatformType.MISTRAL,
    model_type=ModelType.MAGISTRAL_MEDIUM_1_2,
    model_config_dict=MistralConfig(temperature=0.0).as_dict(),
)

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

response = agent.step("Say hi to CAMEL AI community.")
print(response.msgs[0].content)

Leveraging Anthropic’s Claude models within CAMEL:

from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
from camel.configs import AnthropicConfig
from camel.agents import ChatAgent

model = ModelFactory.create(
    model_platform=ModelPlatformType.ANTHROPIC,
    model_type=ModelType.CLAUDE_HAIKU_4_5,
    model_config_dict=AnthropicConfig(temperature=0.2).as_dict(),
)

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

response = agent.step("Say hi to CAMEL AI community.")
print(response.msgs[0].content)

Leverage CometAPI’s unified access to multiple frontier AI models:

CometAPI Platform (CometAPI):
API Key Setup: Obtain your CometAPI key to start integration.
OpenAI Compatible: Use familiar OpenAI API patterns with advanced frontier models.

from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
from camel.configs import CometAPIConfig
from camel.agents import ChatAgent

model = ModelFactory.create(
    model_platform=ModelPlatformType.COMETAPI,
    model_type=ModelType.COMETAPI_GPT_5_CHAT_LATEST,
    model_config_dict=CometAPIConfig(temperature=0.2).as_dict(),
)

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

response = agent.step("Say hi to CAMEL AI community.")
print(response.msgs[0].content)

Flexible Model Access: You can use any model available on CometAPI by passing the model name as a string to model_type, even if it’s not in the predefined enums.

Environment Variables:

export COMETAPI_KEY="your_cometapi_key_here"
export COMETAPI_API_BASE_URL="https://api.cometapi.com/v1/" # Optional

Model Support:

Complete Access: All models available on CometAPI are supported
Predefined Enums: Common models like COMETAPI_GPT_5_CHAT_LATEST, COMETAPI_CLAUDE_OPUS_4_1_20250805, etc.
String-based Access: Use any model name directly as a string for maximum flexibility

Example with different models:

# Access multiple frontier models through CometAPI
models_to_try = [
    ModelType.COMETAPI_GPT_5_CHAT_LATEST,
    ModelType.COMETAPI_GPT_5,
    ModelType.COMETAPI_GPT_5_MINI,
    ModelType.COMETAPI_CLAUDE_OPUS_4_1_20250805,
    ModelType.COMETAPI_CLAUDE_SONNET_4_20250514,
    ModelType.COMETAPI_CLAUDE_3_7_SONNET_LATEST,
    ModelType.COMETAPI_GEMINI_2_5_PRO,
    ModelType.COMETAPI_GEMINI_2_5_FLASH,
    ModelType.COMETAPI_GROK_4_0709,
    ModelType.COMETAPI_GROK_3,
    ModelType.COMETAPI_DEEPSEEK_V3_1,
    ModelType.COMETAPI_DEEPSEEK_V3,
    ModelType.COMETAPI_QWEN3_30B_A3B,
    ModelType.COMETAPI_QWEN3_CODER_PLUS_2025_07_22
]

for model_type in models_to_try:
    model = ModelFactory.create(
        model_platform=ModelPlatformType.COMETAPI,
        model_type=model_type
    )
    # Use the model...

Leverage Nebius AI Studio’s high-performance GPU cloud with OpenAI-compatible models:

Nebius AI Studio (Platform): Access powerful models through their cloud infrastructure.
API Key Setup (Generate Key): Obtain your Nebius API key to start integration.
Nebius Docs (Documentation): Explore detailed Nebius API capabilities.

from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
from camel.configs import NebiusConfig
from camel.agents import ChatAgent

model = ModelFactory.create(
    model_platform=ModelPlatformType.NEBIUS,
    model_type=ModelType.NEBIUS_GPT_OSS_120B,
    model_config_dict=NebiusConfig(temperature=0.2).as_dict(),
)

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

response = agent.step("Say hi to CAMEL AI community.")
print(response.msgs[0].content)

Flexible Model Access: You can use any model available on Nebius by passing the model name as a string to model_type, even if it’s not in the predefined enums.

Environment Variables:

export NEBIUS_API_KEY="your_nebius_api_key"
export NEBIUS_API_BASE_URL="https://api.studio.nebius.com/v1"  # Optional

Model Support:

Complete Access: All models available on Nebius AI Studio are supported
Predefined Enums: Common models like NEBIUS_GPT_OSS_120B, NEBIUS_DEEPSEEK_V3, etc.
String-based Access: Use any model name directly as a string for maximum flexibility

Example with any model:

# Use any model available on Nebius
model = ModelFactory.create(
    model_platform=ModelPlatformType.NEBIUS,
    model_type="your-custom-model-name"  # Any Nebius model
)

Leverage Qwen’s state-of-the-art models for coding and reasoning:

from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
from camel.configs import QwenConfig
from camel.agents import ChatAgent

model = ModelFactory.create(
    model_platform=ModelPlatformType.QWEN,
    model_type=ModelType.QWEN_2_5_CODER_32B,
    model_config_dict=QwenConfig(temperature=0.2).as_dict(),
)

agent = ChatAgent(system_message="You are a helpful assistant.", model=model)
response = agent.step("Give me Python code to develop a trading bot.")
print(response.msgs[0].content)

Access a wide variety of models through OpenRouter’s unified API:Setup: Set your OpenRouter API key as an environment variable:

export OPENROUTER_API_KEY="your-api-key-here"

from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
from camel.configs import OpenRouterConfig
from camel.agents import ChatAgent

# Using predefined OpenRouter models
model = ModelFactory.create(
    model_platform=ModelPlatformType.OPENROUTER,
    model_type=ModelType.OPENROUTER_LLAMA_3_1_70B,
    model_config_dict=OpenRouterConfig(temperature=0.2).as_dict(),
)

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

response = agent.step("Say hi to CAMEL AI community.")
print(response.msgs[0].content)

CAMEL supports several predefined OpenRouter models including:

OPENROUTER_LLAMA_3_1_405B - Meta’s Llama 3.1 405B model
OPENROUTER_LLAMA_3_1_70B - Meta’s Llama 3.1 70B model
OPENROUTER_LLAMA_4_MAVERICK - Meta’s Llama 4 Maverick model
OPENROUTER_LLAMA_4_SCOUT - Meta’s Llama 4 Scout model
OPENROUTER_OLYMPICODER_7B - Open R1’s OlympicCoder 7B model
OPENROUTER_HORIZON_ALPHA - Horizon Alpha model

Free versions are also available for some models (e.g., OPENROUTER_LLAMA_4_MAVERICK_FREE).

You can also use any OpenRouter model via the OpenAI-compatible interface:

import os
from camel.models import ModelFactory
from camel.types import ModelPlatformType

# Use any model available on OpenRouter
model = ModelFactory.create(
    model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
    model_type="anthropic/claude-3.5-sonnet",  # Any OpenRouter model
    url="https://openrouter.ai/api/v1",
    api_key=os.getenv("OPENROUTER_API_KEY"),
    model_config_dict={"temperature": 0.2},
)

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

response = agent.step("Explain quantum computing in simple terms.")
print(response.msgs[0].content)

Available Models: View the full list of models available through OpenRouter at openrouter.ai/models.

Using Groq’s powerful models (e.g., Llama 3.3-70B):

from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType
from camel.configs import GroqConfig
from camel.agents import ChatAgent

model = ModelFactory.create(
    model_platform=ModelPlatformType.GROQ,
    model_type=ModelType.GROQ_LLAMA_3_3_70B,
    model_config_dict=GroqConfig(temperature=0.2).as_dict(),
)

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

response = agent.step("Say hi to CAMEL AI community.")
print(response.msgs[0].content)

Using OpenAI-Compatible Models

If your provider exposes an OpenAI-compatible API, you can connect it by using OPENAI_COMPATIBLE_MODEL and passing the model name as a string. This lets you reuse the same request patterns while pointing to a different endpoint.

import os
from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.types import ModelPlatformType

model = ModelFactory.create(
    model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
    model_type="your-model-name", #e.g. "gpt-4o"
    url="https://your-openai-compatible-endpoint/v1",
    api_key=os.getenv("OPENAI_COMPATIBLE_API_KEY"),
    model_config_dict={"temperature": 0.2},
)

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

response = agent.step("Explain quantum computing in simple terms.")
print(response.msg.content)

Replace the model name, base URL, and API key with values provided by your OpenAI-compatible service.

Using On-Device Open Source Models

Run Open-Source LLMs Locally

Unlock true flexibility: CAMEL-AI supports running popular LLMs right on your own machine. Use Ollama, vLLM, or SGLang to experiment, prototype, or deploy privately (no cloud required).

CAMEL-AI makes it easy to integrate local open-source models as part of your agent workflows. Here’s how you can get started with the most popular runtimes:

Using Ollama for Llama 3

Install Ollama

Download Ollama and follow the installation steps for your OS.

Pull the Llama 3 model

ollama pull llama3

(Optional) Create a Custom Model

Create a file named Llama3ModelFile:

FROM llama3

PARAMETER temperature 0.8
PARAMETER stop Result

SYSTEM """ """

You can also create a shell script setup_llama3.sh:

#!/bin/zsh
model_name="llama3"
custom_model_name="camel-llama3"
ollama pull $model_name
ollama create $custom_model_name -f ./Llama3ModelFile
chmod +x setup_llama3.sh
./setup_llama3.sh

Integrate with CAMEL-AI

from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.types import ModelPlatformType

ollama_model = ModelFactory.create(
    model_platform=ModelPlatformType.OLLAMA,
    model_type="llama3",
    url="http://localhost:11434/v1",
    model_config_dict={"temperature": 0.4},
)
agent = ChatAgent("You are a helpful assistant.", model=ollama_model)
response = agent.step("Say hi to CAMEL")
print(response.msg.content)

Using vLLM for Phi-3

Install vLLM

Follow the vLLM installation guide for your environment.

Start the vLLM server

python -m vllm.entrypoints.openai.api_server \
  --model microsoft/Phi-3-mini-4k-instruct \
  --api-key vllm --dtype bfloat16

Integrate with CAMEL-AI

from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.types import ModelPlatformType

vllm_model = ModelFactory.create(
    model_platform=ModelPlatformType.VLLM,
    model_type="microsoft/Phi-3-mini-4k-instruct",
    url="http://localhost:8000/v1",
    model_config_dict={"temperature": 0.0},
)
agent = ChatAgent("You are a helpful assistant.", model=vllm_model)
response = agent.step("Say hi to CAMEL AI")
print(response.msg.content)

Using SGLang for Meta-Llama

Install SGLang

Follow the SGLang install instructions for your platform.

Integrate with CAMEL-AI

from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.types import ModelPlatformType

sglang_model = ModelFactory.create(
    model_platform=ModelPlatformType.SGLANG,
    model_type="meta-llama/Llama-3.2-1B-Instruct",
    model_config_dict={"temperature": 0.0},
    api_key="sglang",
)
agent = ChatAgent("You are a helpful assistant.", model=sglang_model)
response = agent.step("Say hi to CAMEL AI")
print(response.msg.content)

Looking for more examples?

Explore the full CAMEL-AI Examples library for advanced workflows, tool integrations, and multi-agent demos.

Next Steps

You’ve now seen how to connect, configure, and optimize models with CAMEL-AI.

Continue: Working with Messages

Learn how to create, format, and convert BaseMessage objects—the backbone of agent conversations in CAMEL-AI.

Get Started

Key Modules

Awesome Toolkits

CAMEL with MCP

Cookbooks

Models

Large Language Models (LLMs)

Flexible Model Integration

Optimized for Customization

Rapid Experimentation

Supported Model Platforms in CAMEL

Direct Integrations

API & Connector Platforms

How to Use Models via API Calls

Using OpenAI-Compatible Models

Using On-Device Open Source Models

Run Open-Source LLMs Locally

Looking for more examples?

Next Steps

Continue: Working with Messages

Large Language Models (LLMs)

Flexible Model Integration

Optimized for Customization

Rapid Experimentation

​Supported Model Platforms in CAMEL

​Direct Integrations

​API & Connector Platforms

​How to Use Models via API Calls

​Using OpenAI-Compatible Models

​Using On-Device Open Source Models

Run Open-Source LLMs Locally

Looking for more examples?

​Next Steps

Continue: Working with Messages

Supported Model Platforms in CAMEL

Direct Integrations

API & Connector Platforms

How to Use Models via API Calls

Using OpenAI-Compatible Models

Using On-Device Open Source Models

Next Steps