š« CAMEL: The first and the best multi-agent framework. Finding the Scaling Law of Agents. https://www.camel-ai.org
title: "Models" description: "CAMEL-AI: Flexible integration and deployment of top LLMs and multimodal models like OpenAI, Mistral, Gemini, Llama, Nebius, and more." icon: gear-code
doc_code_map: - "camel/models/**/*.py"
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.
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. 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. Customize performance parameters such as temperature, token limits, and response structures easily, balancing creativity, accuracy, and efficiency. 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-2025-04-14, gpt-4.1-nano-2025-04-14 gpt-5, gpt-5-mini, gpt-5-nano gpt-5.1, gpt-5.2 gpt-5.4, gpt-5.4-mini-2026-03-17, gpt-5.4-nano-2026-03-17 gpt-5.5, gpt-5.5-pro-2026-04-23 gpt-4-turbo, gpt-4, gpt-3.5-turbo |
| Azure 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-2025-04-14, gpt-4.1-nano-2025-04-14 gpt-5 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 | kimi-k2-0905-Preview, kimi-k2.5, kimi-k2-turbo-preview kimi-k2-thinking, kimi-k2-thinking-turbo 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-6, claude-opus-4-6, claude-opus-4-7, claude-opus-4-8 claude-sonnet-4-20250514, claude-opus-4-20250514, claude-opus-4-1-20250805 |
| Gemini | gemini-3.1-pro-preview, gemini-3.1-flash-lite-preview gemini-3-pro-preview, gemini-3-flash-preview gemini-2.5-pro, gemini-2.5-flash gemini-2.0-flash, gemini-2.0-flash-exp gemini-2.0-flash-thinking-exp, gemini-2.0-pro-exp-02-05 gemini-2.0-flash-lite, gemini-2.0-flash-lite-preview-02-05 |
| Qwen | qwen3-coder-plus 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, qwen2.5-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 qwq-32b-preview, qwq-plus, qvq-72b-preview |
| DeepSeek | deepseek-v4-flash, deepseek-v4-pro deepseek-chat, deepseek-reasoner |
| ZhipuAI | glm-5.2, glm-5.1, glm-5, glm-4.7, glm-4.7-flash, glm-4.7-flashx glm-4.6, glm-4.6v, glm-4.6v-flash, glm-4.6v-flashx glm-4.5v, glm-4.5-air, glm-4.5-airx, glm-4.5-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.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 ernie-5.0-thinking-latest, ernie-4.5-turbo-vl-latest deepseek-v3, deepseek-r1, qwen3-235b-a22b |
| MiniMax | MiniMax-M3, MiniMax-M2.7, MiniMax-M2.7-highspeed MiniMax-M2.5, MiniMax-M2.1, MiniMax-M2.1-lightning, MiniMax-M2 |
| xAI | Grok models via the xAI SDK |
API & Connector Platforms
| Model Platform | Supported via API/Connector |
|---|---|
| GROQ | supported models |
| TOGETHER AI | supported models |
| SambaNova | supported models |
| Ollama | supported models |
| CometAPI | supported models |
| Nebius | supported models |
| OpenRouter | supported models |
| OrcaRouter | supported models |
| PPIO | supported models |
| LiteLLM | supported models |
| OpenAI Compatible | custom OpenAI-compatible endpoints via OPENAI_COMPATIBLE_MODEL |
| 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 |
| AIHubMix | supported models |
| AtlasCloud | openai/gpt-oss-120b, zai-org/glm-4-7 |
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...
Use Nebius Token Factory with CAMEL's OpenAI-compatible model interface:
- Token Factory (Platform): Run models through the managed inference API.
- API Key Setup (Generate Key): Obtain a Token Factory API key.
- Token Factory Docs (Documentation): Explore the API and supported capabilities.
from camel.models import ModelFactory
from camel.types import ModelPlatformType
from camel.configs import NebiusConfig
from camel.agents import ChatAgent
model = ModelFactory.create(
model_platform=ModelPlatformType.NEBIUS,
model_type="openai/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:** Pass a model ID from the live [Token Factory model catalog](https://tokenfactory.nebius.com/model-catalog.md) as a string to `model_type`. This avoids coupling an application to CAMEL's legacy convenience enums as the catalog changes.
Environment Variables:
export NEBIUS_API_KEY="your_nebius_api_key"
export NEBIUS_API_BASE_URL="https://api.tokenfactory.nebius.com/v1" # Optional
Model Support:
- Catalog-backed selection: Choose an active model ID from the public catalog
- String-based access: Use the catalog model ID directly so newly available models do not require a CAMEL release
- Compatibility: Existing
NEBIUS_*enum values remain available, but their upstream model lifecycle may differ
Example with any model:
# Use any active model ID from the Token Factory model catalog
model = ModelFactory.create(
model_platform=ModelPlatformType.NEBIUS,
model_type="openai/gpt-oss-120b"
)
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](https://openrouter.ai/)'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
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:
Download Ollama and follow the installation steps for your OS. ```bash ollama pull llama3 ``` Create a file namedLlama3ModelFile:
```
FROM llama3
PARAMETER temperature 0.8
PARAMETER stop Result
SYSTEM """ """
```
You can also create a shell script <code>setup_llama3.sh</code>:
```bash
#!/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
```
</Step>
<Step title="Integrate with CAMEL-AI">
```python
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)
```
</Step>
</Steps>
Follow the vLLM installation guide for your environment.
```bash
python -m vllm.entrypoints.openai.api_server \
--model microsoft/Phi-3-mini-4k-instruct \
--api-key vllm --dtype bfloat16
```
```python
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)
```
</Step>
</Steps>
Follow the SGLang install instructions for your platform.
```python
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)
```
</Step>
</Steps>
<Card title="Looking for more examples?" icon="book" href="https://github.com/camel-ai/camel/tree/master/examples/models"
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.
<Card title="Continue: Working with Messages" icon="arrow-right" href="https://docs.camel-ai.org/key_modules/messages"
Learn how to create, format, and convert BaseMessage objectsāthe backbone of agent conversations in CAMEL-AI.