> ## Documentation Index
> Fetch the complete documentation index at: https://docs.camel-ai.org/llms.txt
> Use this file to discover all available pages before exploring further.
# Models
> CAMEL-AI: Flexible integration and deployment of top LLMs and multimodal models like [OpenAI](https://openai.com/), [Mistral](https://mistral.ai/), [Gemini](https://ai.google.dev/gemini-api/docs/models), [Llama](https://www.llama.com/), [Nebius](https://nebius.com/), and more.
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](https://colab.research.google.com/drive/18hQLpte6WW2Ja3Yfj09NRiVY-6S2MFu7?usp=sharing).
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](https://platform.openai.com/docs/models), [Meta’s Llama models](https://www.llama.com/), [DeepSeek models](https://www.deepseek.com/) (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](https://api.cometapi.com/pricing)**
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](https://studio.nebius.com/)**
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](https://console.groq.com/docs/models) |
| **TOGETHER AI** | [supported models](https://docs.together.ai/docs/dedicated-models) |
| **SambaNova** | [supported models](https://docs.sambanova.ai/cloud/docs/get-started/supported-models) |
| **Ollama** | [supported models](https://ollama.com/library) |
| **OpenRouter** | [supported models](https://openrouter.ai/models) |
| **PPIO** | [supported models](https://ppio.com/model-api/console) |
| **LiteLLM** | [supported models](https://docs.litellm.ai/docs/providers) |
| **LMStudio** | [supported models](https://lmstudio.ai/models) |
| **vLLM** | [supported models](https://docs.vllm.ai/en/latest/models/supported_models.html) |
| **SGLANG** | [supported models](https://docs.sglang.ai/supported_models/generative_models.html) |
| **NetMind** | [supported models](https://www.netmind.ai/modelsLibrary) |
| **NOVITA** | [supported models](https://novita.ai/models?utm_source=github_owl\&utm_medium=github_readme\&utm_campaign=github_link) |
| **NVIDIA** | [supported models](https://docs.api.nvidia.com/nim/reference/llm-apis) |
| **AIML** | [supported models](https://docs.aimlapi.com/api-overview/model-database/text-models) |
| **ModelScope** | [supported models](https://www.modelscope.cn/docs/model-service/API-Inference/intro) |
| **AWS Bedrock** | [supported models](https://us-west-2.console.aws.amazon.com/bedrock/home?region=us-west-2#/) |
| **IBM WatsonX** | [supported models](https://jp-tok.dataplatform.cloud.ibm.com/samples?context=wx\&tab=foundation-model) |
| **Crynux** | [supported models](https://docs.crynux.ai/application-development/how-to-run-llm-using-crynux-network/supported-models) |
| **SiliconFlow** | [supported models](https://cloud.siliconflow.cn/me/models) |
| **AMD** | dvue-aoai-001-gpt-4.1 |
| **Volcano** | [supported models](https://console.volcengine.com/ark) |
| **Qianfan** | [supported models](https://cloud.baidu.com/doc/qianfan/s/rmh4stp0j) |
## 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:
```python theme={"system"}
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](https://aistudio.google.com/)): Try models quickly in a no-code environment.
* **API Key Setup** ([Generate Key](https://aistudio.google.com/app/apikey)): Obtain your Gemini API key to start integration.
* **Gemini API Docs** ([Deep Dive](https://ai.google.dev/gemini-api/docs)): Explore detailed Gemini API capabilities.
```python theme={"system"}
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:
```python theme={"system"}
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:
```python theme={"system"}
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](https://api.cometapi.com/)'s unified access to multiple frontier AI models:
* **CometAPI Platform** ([CometAPI](https://www.cometapi.com/?utm_source=camel-ai\&utm_campaign=integration\&utm_medium=integration\&utm_content=integration)):
* **API Key Setup**: Obtain your CometAPI key to start integration.
* **OpenAI Compatible**: Use familiar OpenAI API patterns with advanced frontier models.
```python theme={"system"}
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:**
```bash theme={"system"}
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](https://api.cometapi.com/) 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:**
```python theme={"system"}
# 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](https://nebius.com/)'s high-performance GPU cloud with OpenAI-compatible models:
* **Nebius AI Studio** ([Platform](https://studio.nebius.com/)): Access powerful models through their cloud infrastructure.
* **API Key Setup** ([Generate Key](https://studio.nebius.ai/settings/api-keys)): Obtain your Nebius API key to start integration.
* **Nebius Docs** ([Documentation](https://nebius.com/docs/)): Explore detailed Nebius API capabilities.
```python theme={"system"}
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:**
```bash theme={"system"}
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](https://studio.nebius.com/) 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:**
```python theme={"system"}
# Use any model available on Nebius
model = ModelFactory.create(
model_platform=ModelPlatformType.NEBIUS,
model_type="your-custom-model-name" # Any Nebius model
)
```
Leverage [Qwen](https://qwenlm.github.io/)'s state-of-the-art models for coding and reasoning:
```python theme={"system"}
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:
```bash theme={"system"}
export OPENROUTER_API_KEY="your-api-key-here"
```
```python theme={"system"}
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:
```python theme={"system"}
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](https://openrouter.ai/models).
Using [Groq](https://groq.com/)'s powerful models (e.g., Llama 3.3-70B):
```python theme={"system"}
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.
```python theme={"system"}
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 theme={"system"}
ollama pull llama3
```
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:
```bash theme={"system"}
#!/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
```
```python theme={"system"}
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)
```
Follow the vLLM installation guide for your environment.
```bash theme={"system"}
python -m vllm.entrypoints.openai.api_server \
--model microsoft/Phi-3-mini-4k-instruct \
--api-key vllm --dtype bfloat16
```
```python theme={"system"}
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)
```
Follow the SGLang install instructions for your platform.
```python theme={"system"}
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)
```
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.
Learn how to create, format, and convert BaseMessage objects—the backbone of agent conversations in CAMEL-AI.