◆ AI Agent Frameworks

camel-ai

v0.2.90 open-source

CAMEL: The first and the best multi-agent framework. Finding the Scaling Law of Agents. https://www.camel-ai.org

source ↗ website ↗ rss ↗ last repo push Aug 27, 2026

from camel.toolkits.mcp import PulseMCPSearchToolkit
search_toolkit = PulseMCPSearchToolkit()
results = search_toolkit.search_mcp_servers(query="Slack", top_k=1)
print(results)
from camel.toolkits import TerminalToolkit

toolkit = TerminalToolkit()
# Write a script to disk, then block until a build command completes
toolkit.shell_write_content_to_file(content="echo hello", file_path="/tmp/hello.sh")
toolkit.shell_wait(command="bash /tmp/hello.sh")
from camel.workforce.events import TaskUpdatedEvent, TaskCompletedEvent, TaskFailedEvent

def on_event(event):
    if isinstance(event, TaskUpdatedEvent):
        print(f"Task updated: {event}")
    elif isinstance(event, TaskCompletedEvent):
        print(f"Done (parent={event.parent_task_id})")
    elif isinstance(event, TaskFailedEvent):
        print(f"Failed (parent={event.parent_task_id})")
from camel.toolkits import SerpApiToolkit
from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType

toolkit = SerpApiToolkit()
model = ModelFactory.create(
    model_platform=ModelPlatformType.OPENAI,
    model_type=ModelType.GPT_4O,
)
agent = ChatAgent(model=model, tools=toolkit.get_tools())
response = agent.step('What are the top results for "AI agent frameworks" today?')
print(response.msgs[0].content)
agent.summarize(directory='/tmp/agent_summaries/')
from camel.toolkits import TerminalToolkit

toolkit = TerminalToolkit()
tools = toolkit.get_tools()
from camel.toolkits import SearchToolkit

toolkit = SearchToolkit(excluded_domains=['spamsite.com', 'lowqualityblog.net'])
results = toolkit.search_google('latest vulnerability disclosures 2024')
for r in results:
    print(r)
from camel.toolkits import Crawl4AIToolkit
from camel.agents import ChatAgent

toolkit = Crawl4AIToolkit()
agent = ChatAgent(tools=toolkit.get_tools())
response = agent.step("Crawl https://example.com and summarize the content.")
workforce = Workforce('My Pipeline')
workforce.add_single_agent_worker('Researcher', worker=researcher_agent)
mcp_server = workforce.to_mcp()
mcp_server.run()
from camel.toolkits import FileWriteToolkit

toolkit = FileWriteToolkit()
toolkit.latex_to_pdf(latex_content=r"\documentclass{article}\begin{document}Hello, CAMEL!\end{document}", output_path="report.pdf")
from camel.loaders import MarkItDownLoader

loader = MarkItDownLoader()
docs = loader.load("report.pdf")
from camel.toolkits import MCPToolkit

config = {
    "mcpServers": {
        "my_server": {
            "url": "http://localhost:8000"
        }
    }
}
toolkit = MCPToolkit(config=config)
from camel.toolkits import MCPToolkit

toolkit = MCPToolkit(config_path="mcp_config.json", strict=True)
from camel.toolkits import HumanToolkit

toolkit = HumanToolkit()
toolkit.send_message_to_user('Task complete — results saved to output.csv')
from camel.toolkits import TerminalToolkit, FileWriteToolkit

terminal = TerminalToolkit()
file_writer = FileWriteToolkit()

# Pass both toolkits to your agent
tools = terminal.get_tools() + file_writer.get_tools()
from camel.toolkits import ExcelToolkit
from camel.agents import ChatAgent

toolkit = ExcelToolkit()
agent = ChatAgent(tools=toolkit.get_tools())
agent.step('Summarize the data in report.xlsx')
from camel.data_collector import AlpacaItem

item = AlpacaItem(instruction='Explain XSS', input='', output='Cross-site scripting is...')
print(item.model_dump())
retriever.process(content="https://example.com/doc", extra_payload={"source": "internal", "priority": 1})
from camel.agents import ChatAgent

agent = ChatAgent()  # system_message now optional
response = agent.step('Summarize the latest AI news')
print(response.msg.content)
from camel.toolkits import FunctionTool
from camel.agents import ChatAgent

def get_weather(city: str) -> str:
    return f'Sunny in {city}'

tool = FunctionTool(get_weather)
agent = ChatAgent(tools=[tool])
response = agent.step('What is the weather in Paris?')
print(response.msg.content)
from camel.toolkits import RetrievalToolkit

toolkit = RetrievalToolkit(
    top_k=5,
    similarity_threshold=0.75,
)
from camel.models import OpenAICompatibilityModel

model = OpenAICompatibilityModel(
    model_type="llama3",
    url="http://localhost:11434/v1",
    api_key="none",
)

Summary

camel-ai is an open-source agent framework designed to study the scaling laws of AI agents, making it available under the MIT license. It is positioned for researchers and practitioners interested in multi-agent systems, communicative agents, and research tooling. The framework supports implementing various agent types, tasks, prompts, models, and simulated environments for agent behavior analysis. Users interact with the system via its repository and documentation. The project shows ongoing community dedication, evidenced by its multiple official documentation links and active community hubs.

CAMEL: The first and the best multi-agent framework. Finding the Scaling Law of Agents. https://www.camel-ai.org

What camel-ai answers

What types of interactions does it support for agents?

It supports various agent types, tasks, prompts, models, and simulated environments.

Can it be used to study how agent behavior changes with scale?

It is designed for studying the scaling laws of AI agents.

Does it provide ways to generate data?

It supports data generation.

What kind of systems can I automate using this framework?

It supports task automation.

Where can I find examples of how to use the framework?

Examples are available in the project's repository.

What languages are provided for accessing the documentation?

Documentation is available in English, Simplified Chinese, and Japanese.

Command line

composed command

option surface across analysed releases

options at that release added, per release removed, per release

option	found in	since	description

Values are placeholders taken from each option’s declared default. Nothing is executed here — the output shown is a recording of a run that already happened.

Release history

docs update Aug 29, 2026 · issue 010

Adds PulseMCPSearchToolkit for searching MCP servers by keyword from within CAMEL agents
└──▷ USE IT
Discover available MCP servers matching a keyword (e.g. 'Slack') to find integrations your agent can connect to.
python
```
from camel.toolkits.mcp import PulseMCPSearchToolkit
search_toolkit = PulseMCPSearchToolkit()
results = search_toolkit.search_mcp_servers(query="Slack", top_k=1)
print(results)
```
- ›Adds PulseMCPSearchToolkit with a search_mcp_servers(query, top_k) method to discover available MCP servers by keyword search directly from Python code.
v0.2.90 Mar 22, 2026 · issue -150

camel-ai v0.2.90 adds new LLM providers, headless browser toolkit, response API support, and expanded prompt caching.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.90 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.90
```
- ›Adds request_level_token_callback support via feat:add_request_level_token_callback, enabling per-request token usage tracking callbacks.
- ›Adds advanced ANN query options to the OceanBase integration (bumps pyobvector to 0.2.22).
- ›Adds a headless browser search toolkit with enhanced browser stealth mode.
- ›Adds TerminalToolkit safe-mode sanitization to restrict dangerous command execution.
- ›Auto-coerces dict arguments to Pydantic models inside FunctionTool, removing manual conversion boilerplate.
+9 moreshow less
- ›Adds unified streaming response handling and callback integration for workforce.
- ›Supports the OpenAI Responses API via feat: support response api.
- ›Extends prompt caching support to additional providers beyond Anthropic.
- ›Adds async support for the AWS Bedrock Converse API.
- ›Adds interleaved thinking for Kimi K2 and GLM models.
- ›Adds new models: MiniMax-M2.5, MiniMax-M2.7, MiniMax-M2.7-highspeed, GLM5, and gemini 3.1 to the model enum list.
- ›Adds gpt-5.4 to the model enum list.
- ›Adds Avian as a new LLM provider.
- ›Adds skill filter capability to workforce task routing.
└──▷ BREAKING ON UPGRADE
- !Removes the default 180-second timeout threshold that was previously applied globally.
v0.2.86 Feb 10, 2026 · issue -188

camel-ai v0.2.86 adds Kimi K2.5 and Claude Opus 4.6 support, prompt caching, browser visual pixel mode, ChatAgent skills, Jina reranking, and file upload/download tooling.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.86 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.86
```
- ›Adds support for kimi k2.5 as a model backend.
- ›Adds support for claude-opus-4-6 as a model backend.
- ›Adds prompt caching support for compatible model backends.
- ›Adds browser visual pixel mode to hybrid_browser_toolkit, enabling pixel-level visual interaction with web pages.
- ›Adds file upload and download tool for agent workflows.
+4 moreshow less
- ›Adds ChatAgent skills system, including a skill creator with scripts and reference documentation.
- ›Adds Jina reranking integration for retrieval pipelines.
- ›Adds typed parameter definitions and supported format declarations to EarthScienceToolkit, and expands supported formats in MarkItDownLoader.
- ›Unifies cleanup handling across all runtimes for consistent teardown behavior.
v0.2.85 Jan 26, 2026 · issue -203

camel-ai v0.2.85 adds Zhipu GLM 4.1V-thinking, 4.5, 4.6, and 4.7 model support
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.85 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.85
```
- ›Adds support for Zhipu's GLM-4.1V-thinking, GLM-4.5, GLM-4.6, and GLM-4.7 models.
v0.2.83 Jan 19, 2026 · issue -210

camel-ai v0.2.83 adds Outlook mail, Lark, IMAP, Serper.dev, AtlasCloud, and Gemma integrations plus new workforce task events
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.83 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.83
```
└──▷ USE IT
Write a file and wait for a long-running shell command to finish inside a TerminalToolkit session.
python
```
from camel.toolkits import TerminalToolkit

toolkit = TerminalToolkit()
# Write a script to disk, then block until a build command completes
toolkit.shell_write_content_to_file(content="echo hello", file_path="/tmp/hello.sh")
toolkit.shell_wait(command="bash /tmp/hello.sh")
```
Listen for task-lifecycle events — including the new TaskUpdatedEvent — to audit workforce task modifications in real time.
python
```
from camel.workforce.events import TaskUpdatedEvent, TaskCompletedEvent, TaskFailedEvent

def on_event(event):
    if isinstance(event, TaskUpdatedEvent):
        print(f"Task updated: {event}")
    elif isinstance(event, TaskCompletedEvent):
        print(f"Done (parent={event.parent_task_id})")
    elif isinstance(event, TaskFailedEvent):
        print(f"Failed (parent={event.parent_task_id})")
```
- ›Adds SearchToolkit support for Serper.dev as a search provider.
- ›Adds shell_wait and shell_write_content_to_file tools to TerminalToolkit.
- ›Adds parent_task_id field to TaskCompletedEvent and TaskFailedEvent in the workforce module.
- ›Adds TaskUpdatedEvent to the workforce module for tracking task modifications.
- ›Adds Microsoft Outlook mail actions toolkit for reading and sending mail.
+11 moreshow less
- ›Adds Lark integration (lark_send_message and related toolkit) for messaging via Lark/Feishu.
- ›Adds IMAP mail integration for reading email via IMAP.
- ›Adds AtlasCloud model backend integration.
- ›Adds Gemma model integration via new function-calling support.
- ›Emits TaskFailedEvent on workforce quality-check failures.
- ›Improves timeout handling for BaseToolkit and TerminalToolkit.
- ›Skips virtual environment creation in TerminalToolkit if the environment already exists.
- ›Enhances workforce task judge and fail-handling prompts.
- ›Improves volcano engine reasoning handling in model backends.
- ›Browser toolkit switches from relative navigation to absolute coordinate positioning.
- ›Browser toolkit reads images into context.
v0.2.82 Dec 17, 2025 · issue -243

camel-ai v0.2.82 adds SerpAPI and SQL toolkits, EarthScienceToolkit, configurable Workforce fail handling, GPT-5.2 and Gemini 3 Flash support, and custom ChatAgent in RolePlaying.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.82 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.82
```
└──▷ USE IT
Run a web search inside an agent using the new SerpAPI toolkit to retrieve live search results.
python
```
from camel.toolkits import SerpApiToolkit
from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.types import ModelPlatformType, ModelType

toolkit = SerpApiToolkit()
model = ModelFactory.create(
    model_platform=ModelPlatformType.OPENAI,
    model_type=ModelType.GPT_4O,
)
agent = ChatAgent(model=model, tools=toolkit.get_tools())
response = agent.step('What are the top results for "AI agent frameworks" today?')
print(response.msgs[0].content)
```
- ›Adds SerpApiToolkit for search-engine results via SerpAPI, accessible as a new toolkit integration.
- ›Adds SqlToolkit for agent-driven SQL database interaction.
- ›Adds EarthScienceToolkit with ~100 earth-science-specific tools derived from the Earth-Agent paper.
- ›Adds stream_callback parameter to task execution in Workforce, enabling streaming progress callbacks.
- ›Adds configurable failure handling to Workforce so callers can control behaviour when a subtask fails.
+7 moreshow less
- ›Adds log_message method to WorkforceLogger for structured workforce logging.
- ›Enables shared multi-runtime instances across multiple toolkits within the same workflow.
- ›Supports custom ChatAgent instances inside RolePlaying, allowing callers to supply pre-configured agents for either role.
- ›Adds async support for SiliconFlow model backend.
- ›Renames all Gmail toolkit tool-call names to include a gmail prefix (e.g. gmail_send_email).
- ›Removes deprecated Gemini 1.5 models from the model registry.
- ›Removes deprecated Groq models from the model registry.
└──▷ BREAKING ON UPGRADE
- !Gmail toolkit tool-call names now carry a gmail prefix; any agent prompt, tool-routing logic, or stored conversation referencing the old bare names (e.g. send_email) will no longer match.
- !Deprecated Gemini 1.5 models have been removed; code that instantiates those model identifiers will fail.
- !Deprecated Groq models have been removed; code that instantiates those model identifiers will fail.
v0.2.80 Nov 26, 2025 · issue -264

camel-ai v0.2.80 adds Gemini 3, Claude Opus 4.5, Cerebras, and ERNIE 5.0 Thinking model support alongside workforce running-mode expansion
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.80 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.80
```
- ›Adds support for Gemini 3 models, including thought signatures and streaming mode.
- ›Adds support for Claude Opus 4.5.
- ›Adds Cerebras platform models as a new provider integration.
- ›Adds ERNIE_5_0_THINKING model to the ERNIE model family.
- ›Extends BaseMessage to carry reasoning/thought fields and updates usage accounting in streaming mode.
+6 moreshow less
- ›Terminal toolkit now automatically creates a Docker container if one does not already exist.
- ›Terminal toolkit gains support for installing user-specified dependency packages.
- ›Workforce gains support for additional running modes.
- ›Unifies timeout configuration across the library with a TIMEOUT constant.
- ›Workflow save folder and filename generation is now semantic (human-readable) rather than using opaque identifiers.
- ›Improves async tool execution support across toolkits.
v0.2.79 Nov 13, 2025 · issue -277

camel-ai v0.2.79 adds workforce callbacks, smart workflow retrieval, new model providers, async summarization, and multiple system message support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.79 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.79
```
- ›Adds callback support for Workforce events and metrics logging, enabling hooks into task lifecycle and observability pipelines.
- ›Adds search tool to FileToolkit for searching across files managed by the toolkit.
- ›Supports multiple system messages in ChatAgent with an improved API (Support Multiple System Messages with Better API).
- ›Adds automatic summarization in ChatAgent when token limit is exceeded or a configurable threshold is reached.
- ›Adds async summarize support in ChatAgent for faster Workforce execution.
+10 moreshow less
- ›Adds Smart Workflow Retrieval to Workflow, enabling context-aware session lookup.
- ›Supports better filenames and custom session IDs in Workflow.
- ›Adds async run support for AWS Bedrock model backend.
- ›Supports customized clients in model backends.
- ›Adds AiHubMix as a new model provider.
- ›Adds SiliconFlow model provider support, including Deepseek, InternLM, and Qwen model families.
- ›Adds Minimax M2 model support.
- ›Adds gmail_toolkit integration.
- ›Adds browser sheet tool with input and read capabilities.
- ›Adds Python 3.13 and 3.14 support.
v0.2.76 Oct 11, 2025 · issue -310

camel-ai v0.2.76 adds AMD model platform, microsandbox, WeChat/DingTalk/Resend toolkits, Workforce workflows, and Claude Sonnet 4.5 support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.76 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.76
```
└──▷ USE IT
Summarize a long agent conversation to a directory so context can be reloaded across sessions.
python
```
agent.summarize(directory='/tmp/agent_summaries/')
```
- ›Adds ArtifactTool to provide a Claude-style artifact experience for agents.
- ›Adds configurable accumulated vs. delta streaming mode with memory optimization via feat(agents): add configurable accumulated vs delta streaming with memory optimization.
- ›Adds agent.summarize() with a directory parameter so agents can load and write context summaries to files on disk.
- ›Adds tool-call caching for ChatAgent to avoid redundant tool invocations.
- ›Adds kwargs passthrough to ChunkrReaderConfig for extended configuration of the Chunkr document reader.
+25 moreshow less
- ›Adds AMD model platform support as a new inference backend.
- ›Adds MiniMax MCP toolkit integration for MiniMax model operations.
- ›Integrates microsandbox as a local sandboxed code-execution solution.
- ›Integrates WeChat as a new messaging toolkit.
- ›Integrates Resend as an email-sending toolkit.
- ›Integrates DingTalk toolkit with enhanced capabilities.
- ›Adds Google Vertex AI Veo toolkit for video generation.
- ›Adds ACI toolkit async support.
- ›Adds Grok image support in model integrations.
- ›Adds CometAPI support with new model and configuration classes.
- ›Adds Magistral Small 1.2 and Magistral Medium 1.2 models.
- ›Adds Claude Sonnet 4.5 model support.
- ›Adds Slack get_user_info capability to the Slack toolkit.
- ›Adds Workforce Workflow feature enabling structured multi-agent pipeline execution.
- ›Adds independent task queue support for Workforce.
- ›Adds Pydantic type checking in the MCP decorator.
- ›Adds Markdown agent context handling for structured document processing.
- ›Adds Dynamic File Editing capability for agents.
- ›Refactors MCPToolkits for improved structure.
- ›Refactors terminal_toolkit with Docker backend support and log_dir logging.
- ›Adds log_dir parameter for browser and terminal tools to capture session logs.
- ›Adds browser_som_screenshot enhancement for visual element tagging in browser automation.
- ›Supports image URL as a message directly in model inputs.
- ›Adds agent pool performance metrics and efficiency improvements.
- ›Runs containers as non-root with host UID/GID mapping for improved sandbox security.
v0.2.75 Aug 25, 2025 · issue -356

camel-ai v0.2.75 adds Claude 4.1, GPT-5, Mistral Medium 3.1, Nebius AI Studio, MetaSo search, and a TerminalToolkit MCP server.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.75 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.75
```
└──▷ USE IT
Use the new TerminalToolkit MCP server to give an agent shell access via MCP.
python
```
from camel.toolkits import TerminalToolkit

toolkit = TerminalToolkit()
tools = toolkit.get_tools()
```
- ›Adds TerminalToolkit MCP server, enabling agents to execute terminal commands via the Model Context Protocol.
- ›Updates OpenAIImageToolkit to support generating multiple images in a single call.
- ›Adds Ollama API key configuration support for authenticated Ollama endpoints.
- ›Adds ChatAgent timeout and retry handling for more resilient agent loops.
- ›Adds support for Claude 4.1 models.
+4 moreshow less
- ›Adds support for GPT-5 models.
- ›Adds support for Mistral Medium 3.1 models.
- ›Adds Nebius AI Studio as a new model provider integration.
- ›Adds MetaSo (metaso.cn) API as a new search tool integration.
v0.2.74 Aug 5, 2025 · issue -363

camel-ai v0.2.74 adds custom E2B-compatible sandbox providers, browser console/input tools, snapshot/viewport toolkit, and Horizon Alpha model support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.74 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.74
```
- ›Adds support for custom E2B-compatible sandbox providers, allowing agents to execute code in alternative sandboxed environments beyond the default E2B offering.
- ›Adds console and input tools to the hybrid browser toolkit, enabling agents to interact with browser console output and inject input during browser-based automation.
- ›Adds a snapshot design and viewport toolkit (viewport_toolkit.py) for capturing and reasoning over browser viewport state.
- ›Adds the Horizon Alpha model from OpenRouter as a supported model in CAMEL.
v0.2.73 Jul 30, 2025 · issue -364

camel-ai v0.2.73 adds SurrealDB vector storage, five new toolkits, domain exclusion for Google search, and token-saving tool-call pruning in ChatAgent.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.73 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.73
```
└──▷ USE IT
Exclude competitor or low-quality domains from Google search results inside an agent toolkit.
python
```
from camel.toolkits import SearchToolkit

toolkit = SearchToolkit(excluded_domains=['spamsite.com', 'lowqualityblog.net'])
results = toolkit.search_google('latest vulnerability disclosures 2024')
for r in results:
    print(r)
```
- ›Adds SurrealDBStorage as a new vector storage backend, enabling agents to persist and query embeddings in SurrealDB.
- ›Adds excluded_domains parameter to SearchToolkit definition to exclude specified domains from search_google results at the toolkit level.
- ›Adds timeout parameter to TerminalToolkit to bound how long shell commands may run.
- ›Adds TerminalToolkit auto-installation of uv when it is not present on the host.
- ›Adds tool-call message pruning in ChatAgent to reduce token budget consumed by accumulated tool-call history.
+10 moreshow less
- ›Adds ToolkitMessageIntegration to let agents broadcast structured status messages from within toolkits.
- ›Adds ScreenshotToolkit for capturing screenshots from within agent workflows.
- ›Adds WebDeployToolkit (webdeploy_toolkit) for deploying web artifacts from within agent workflows.
- ›Adds NotionMCPToolkit (notion_mcp_toolkit.py) for interacting with Notion via the MCP protocol.
- ›Adds Origene toolkit integration for agent-driven research workflows.
- ›Adds CDP (Chrome DevTools Protocol) connect support to the browser toolkit via cdp connect.
- ›Adds Python-native browser (py browser) as an additional browser backend.
- ›Adds Qwen Coder model support to the model registry.
- ›Converts invalid MCP schemas to satisfy OpenAI tool-calling requirements automatically.
- ›Updates Mem0 integration to the v2 API.
v0.2.70 Jun 26, 2025 · issue -365

camel-ai v0.2.70 adds PgVector/Chroma storage, Google Drive toolkit, crawl4ai/markitdown toolkits, Mistral Small 3.2, and multimodal Task support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.70 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.70
```
└──▷ USE IT
Use the Crawl4AI toolkit to give an agent web-crawling capability.
python
```
from camel.toolkits import Crawl4AIToolkit
from camel.agents import ChatAgent

toolkit = Crawl4AIToolkit()
agent = ChatAgent(tools=toolkit.get_tools())
response = agent.step("Crawl https://example.com and summarize the content.")
```
- ›Adds extra_body field to vLLM model config, enabling pass-through of provider-specific parameters.
- ›Adds PgVectorStorage implementation for PostgreSQL with pgvector support as a new vector store backend.
- ›Adds ChromaDB as a supported vector database for RAG workflows.
- ›Adds GoogleDriveToolkit for agent access to Google Drive.
- ›Adds Crawl4AIToolkit and MarkItDownToolkit as first-class built-in toolkits.
+9 moreshow less
- ›Adds EdgeOnePagesMCPToolkit and updates browser_nonvisual_human_in_the_loop for human-in-the-loop browser workflows.
- ›Adds Mistral Small 3.2 as a supported model.
- ›Adds non-visual browser method enabling agents to interact with web content without vision capabilities.
- ›Enhances ExcelToolkit with additional spreadsheet operations.
- ›Supports attaching multimodal (image/media) information directly to Task objects.
- ›Adds more built-in operations to the Python interpreter sandbox.
- ›Enhances VideoAnalysisToolkit with updated OCR capability.
- ›Updates TerminalToolkit to support Docker environment log output.
- ›Improves Workforce task assignment robustness and adds JSON validation to agent outputs.
v0.2.68 Jun 18, 2025 · issue -365

camel-ai v0.2.68 adds RLCards board-game environments and parallel task execution to Workforce.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.68 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.68
```
- ›Adds RLCards environments for the Project Loong board game, enabling multi-step reinforcement-learning workflows.
- ›Adds parallelization support to Workforce to improve throughput on multi-agent task pipelines.
- ›Updates Workforce with support for the latest Anthropic models.
v0.2.67 Jun 18, 2025 · issue -365

Camel v0.2.67 adds Workforce shared memory, batch task assignment, KPI metrics, human-in-the-loop, and Qianfan platform integration.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.67 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.67
```
- ›Adds share_memory support to Workforce, enabling agents within a workforce to share a common memory store.
- ›Adds batch task assignment to Workforce, allowing multiple tasks to be dispatched in a single operation.
- ›Adds KPI metrics collection to Workforce for monitoring and measuring workforce performance.
- ›Adds human-in-the-loop capability to Workforce, letting a human intervene in task processing at runtime.
- ›Updates Workforce task processing to async, unlocking non-blocking multi-agent pipelines.
+3 moreshow less
- ›Integrates the Qianfan platform as a new model provider, expanding supported LLM backends.
- ›Enables flexible argument passing on model calls, allowing runtime kwargs to be forwarded to underlying model APIs.
- ›Improves robustness of async operations across core modules.
v0.2.66 Jun 13, 2025 · issue -365

camel-ai v0.2.66 adds strict-mode JSON schema enforcement for tool definitions
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.66 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.66
```
- ›Sets tool schema to follow strict mode, enforcing stricter JSON schema validation on tool definitions passed to the model
v0.2.65 Jun 12, 2025 · issue -365

camel-ai v0.2.65 adds a Task Planning Toolkit, O3-pro model support, persistent browser context, stealth mode, and mock website tooling.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.65 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.65
```
- ›Replaces ChatAgent.single_iteration with max_iteration_ for controlling agent iteration limits.
- ›Adds a new Task Planning Toolkit for structured agent task planning workflows.
- ›Adds support for the O3-pro model.
- ›Supports persistent browser context and stealth mode for browser-based automation.
- ›Adds mock website capability for browser toolkit testing and simulation.
+1 moreshow less
- ›Adds a PowerPoint (pptx) toolkit use-case application.
└──▷ BREAKING ON UPGRADE
- !ChatAgent.single_iteration has been replaced by max_iteration_; any code referencing single_iteration will break on upgrade.
v0.2.64 Jun 11, 2025 · issue -365

camel-ai v0.2.64 adds Weaviate vector storage, Langfuse integration, MCP export for Workforce, Crynux LLM provider, and two new model supports.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.64 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.64
```
└──▷ USE IT
Expose a Workforce multi-agent pipeline as an MCP server so external tools can invoke it via the Model Context Protocol.
python
```
workforce = Workforce('My Pipeline')
workforce.add_single_agent_worker('Researcher', worker=researcher_agent)
mcp_server = workforce.to_mcp()
mcp_server.run()
```
- ›Adds to_mcp method to Workforce, enabling Workforce instances to be exported and used as an MCP server.
- ›Integrates Langfuse as an observability/tracing backend for agent runs.
- ›Adds WeaviateVectorStorage as a new vector storage backend.
- ›Adds Crynux as a new LLM provider.
- ›Adds support for gemini-2.5-pro-preview-06-05 model.
+5 moreshow less
- ›Adds support for Mistral's magistral-medium-2506 model.
- ›Adds dynamic dependency loading so optional integrations are imported on demand rather than at startup.
- ›Enhances Workforce with graceful shutdown support.
- ›Adds attempt information to Task additional info in Workforce, giving agents richer context on retries.
- ›Enhances MCP support to run in synchronous mode.
v0.2.62 Jun 3, 2025 · issue -365

camel-ai v0.2.62 adds a PowerPoint toolkit for agent-driven PPTX generation.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.62 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.62
```
- ›Adds a new pptx toolkit enabling agents to create and manipulate PowerPoint presentations programmatically.
v0.2.61 May 30, 2025 · issue -366

camel-ai v0.2.61 adds FAISS vector storage, Claude 4, MCP agent export, Mistral OCR, and LaTeX-to-PDF tooling
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.61 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.61
```
└──▷ USE IT
Generate a polished PDF report from LaTeX source produced by an agent, using the updated FileWriteToolkit.
python
```
from camel.toolkits import FileWriteToolkit

toolkit = FileWriteToolkit()
toolkit.latex_to_pdf(latex_content=r"\documentclass{article}\begin{document}Hello, CAMEL!\end{document}", output_path="report.pdf")
```
- ›Adds FAISSStorage as a new vector storage backend, giving practitioners a local, high-performance embedding index option alongside existing cloud stores.
- ›Adds ModelManager as an accepted input to ChatAgent, enabling dynamic model routing and fallback strategies at the agent level.
- ›Adds Agent-to-MCP export capability, allowing ChatAgent instances to be exposed as Model Context Protocol servers for interoperability with MCP-compatible clients.
- ›Adds synchronous mcp_toolkit, enabling synchronous MCP tool invocation alongside the existing async interface.
- ›Adds Mistral Document AI integration for advanced OCR processing of documents within the toolkit ecosystem.
+5 moreshow less
- ›Adds LaTeX-to-PDF conversion to FileWriteToolkit, enabling agents to render structured documents directly to PDF.
- ›Adds Bohrium compute platform integration for running camel workloads on Bohrium infrastructure.
- ›Supports Claude 4 models via the ChatAgent model interface.
- ›Updates evol_instruct with new capabilities for instruction evolution and data synthesis workflows.
- ›Updates Chunkr integration to use the Chunkr SDK, replacing the previous direct API approach.
v0.2.60 May 20, 2025 · issue -366

camel-ai v0.2.60 adds streamable HTTP, Jina Reranker API support, extra Azure OpenAI headers, and new Gemini model types.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.60 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.60
```
- ›Adds streamable HTTP transport support for real-time, streaming agent communication.
- ›Adds Jina Reranker API support, enabling remote reranking calls alongside the existing local reranker.
- ›Adds support for passing extra headers to Azure OpenAI requests.
- ›Adds updated Gemini model types including corrected support for Gemini 2.0 Flash.
v0.2.59 May 14, 2025 · issue -366

camel-ai v0.2.59 adds an Airbnb MCP integration and the BrowseComp benchmark for CAMEL agents.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.59 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.59
```
- ›Integrates the BrowseComp benchmark, enabling evaluation of CAMEL agents on complex, multi-step web browsing tasks.
- ›Adds an Airbnb MCP integration use case, demonstrating CAMEL agents operating as MCP clients against an Airbnb MCP server.
v0.2.58 May 11, 2025 · issue -366

camel-ai v0.2.58 adds a MarkItDown loader, MCP search agent, async BrowserToolkit, and Gemini 2.5 Pro preview support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.58 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.58
```
└──▷ USE IT
Load a PDF or Office document into a CAMEL pipeline using the new MarkItDown loader.
python
```
from camel.loaders import MarkItDownLoader

loader = MarkItDownLoader()
docs = loader.load("report.pdf")
```
- ›Adds gemini-2.5-pro-preview-05-06 as a supported model in the GEMINI model family.
- ›Adds a MarkItDown document loader for ingesting files via Microsoft's MarkItDown library.
- ›Adds an MCP search agent enabling agent workflows driven by Model Context Protocol tool servers.
- ›Adds async support to BrowserToolkit, enabling non-blocking browser automation in async agent pipelines.
- ›Improves MCP server launch with a better interface and support for all connection modes.
v0.2.56 May 8, 2025 · issue -366

camel-ai v0.2.56 adds async Mistral support, Mistral Medium model, and a Playwright MCP toolkit.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.56 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.56
```
- ›Adds async implementation to the Mistral model integration, enabling non-blocking LLM calls.
- ›Adds support for the mistral-medium model.
- ›Adds a Playwright MCP toolkit for browser automation within agent workflows.
v0.2.55 May 7, 2025 · issue -366

camel-ai v0.2.55 adds Agent-as-MCP-server, Pulse MCP search, Klavis AI toolkit, and timeout control for MCP sessions.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.55 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.55
```
└──▷ USE IT
Supply MCP server config as a plain dict instead of a config file, useful for dynamically constructed or secrets-managed configs.
python
```
from camel.toolkits import MCPToolkit

config = {
    "mcpServers": {
        "my_server": {
            "url": "http://localhost:8000"
        }
    }
}
toolkit = MCPToolkit(config=config)
```
- ›Adds MCPServer capability to expose a CAMEL agent as an MCP server, letting other MCP clients connect to and invoke the agent directly.
- ›Adds support for passing a Dict as config to the MCP toolkit, complementing the existing file-based config approach.
- ›Adds a timeout argument to MCP session initialization, enabling control over how long the client waits for MCP server responses.
- ›Adds Pulse MCP search toolkits, enabling agents to search the Pulse MCP registry.
- ›Adds list_tools and call_tool functions to the Klavis AI toolkit, allowing agents to enumerate and invoke Klavis AI tools.
v0.2.53 May 5, 2025 · issue -366

camel-ai v0.2.53 adds Gemini embeddings, ACI tool interface, MCP for non-function-calling models, and richer ChatAgent control.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.53 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.53
```
- ›Adds termination parameter to ChatAgent.step() and ChatAgent.astep() to allow callers to inject custom termination conditions at call time.
- ›Enables ModelFactory to accept and pass through additional keyword arguments when constructing model instances.
- ›Adds Gemini embedding support via the existing embeddings interface.
- ›Introduces ACI tool interface (ACI_Tool_interface) for interacting with ACI-based tools.
- ›Enables MCP (Model Context Protocol) for models that do not natively support function calling, expanding MCP compatibility beyond function-calling-capable backends.
v0.2.52 May 3, 2025 · issue -366

camel-ai v0.2.52 adds Klavis toolkit, Daytona runtime integration, and a strict parameter for MCP classes.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.52 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.52
```
└──▷ USE IT
Enforce strict mode when initializing an MCP client to surface connection or schema errors immediately.
python
```
from camel.toolkits import MCPToolkit

toolkit = MCPToolkit(config_path="mcp_config.json", strict=True)
```
- ›Adds strict parameter to the constructors of MCPClient and MCPToolkit classes for stricter MCP connection control.
- ›Adds KlavisToolkit integration for connecting to the Klavis API.
- ›Integrates Daytona runtime support for sandboxed code execution environments.
v0.2.51 May 3, 2025 · issue -366

camel-ai v0.2.51 adds DeepSeek Prover V2 671B via PPIO, SingleStepEnv timeout, and Azure AD token provider support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.51 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.51
```
- ›Adds azure_ad_token_provider support to Azure OpenAI integration, enabling token-based authentication flows.
- ›Adds timeout parameter to SingleStepEnv, enabling time-bounded environment execution.
- ›Adds DeepSeek Prover V2 671B model support via the PPIO provider.
v0.2.50 May 1, 2025 · issue -366

camel-ai v0.2.50 adds Novita and WatsonX LLM providers, Qwen3 support, a Physics verifier, and browser toolkit caching.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.50 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.50
```
- ›Adds Novita as a new LLM provider integration.
- ›Integrates IBM WatsonX as a new LLM provider.
- ›Adds Qwen3 model support via both ModelScope and the qwen_model backend.
- ›Adds a Physics verifier for validating physics-related agent outputs.
- ›Adds caching capability to the Browser Toolkit, reducing redundant network calls.
+1 moreshow less
- ›Simplifies agent creation by accepting a plain string argument in place of a full model config object.
v0.2.49 Apr 26, 2025 · issue -367

camel-ai v0.2.49 adds Netmind as a supported model platform.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.49 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.49
```
- ›Adds support for the Netmind platform as a model backend.
v0.2.47 Apr 23, 2025 · issue -367

camel-ai v0.2.47 adds OceanBase DB integration, Jina reranker, Alibaba Tongxiao Search, ScrapeGraph SDK, and O4-mini/O3 model support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.47 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.47
```
- ›Adds support for O4-mini and O3 models.
- ›Integrates OceanBase database as a new storage/retrieval backend.
- ›Adds a Jina reranker toolkit for reranking retrieval results.
- ›Adds Alibaba Tongxiao Search API support via search_toolkit.
- ›Integrates scrapegraph-sdk for AI-powered web scraping.
v0.2.46 Apr 20, 2025 · issue -367

camel-ai v0.2.46 adds PyAutoGUI toolkit, LM Studio integration, and refreshed AWS Bedrock and OpenAICompatibleModel support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.46 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.46
```
- ›Adds PyAutoGUI toolkit, enabling agents to drive desktop GUI automation through the new pyautogui toolkit interface.
- ›Adds LM Studio integration via LMStudioModel, letting practitioners run locally-hosted LM Studio models as a camel-ai backend.
- ›Updates AWS Bedrock integration with refreshed model support through aws_bedrock.
- ›Enhances OpenAICompatibleModel so all model implementations inherit from it, simplifying custom model integration.
- ›Refactors the video toolkit with expanded capabilities for video processing workflows.
v0.2.45 Apr 15, 2025 · issue -367

camel-ai v0.2.45 adds Ubuntu Docker runtime and OpenAI GPT-4.1 model support
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.45 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.45
```
- ›Supports OpenAI gpt-4.1 as a model backend option.
- ›Adds Ubuntu Docker runtime for sandboxed code execution environments.
- ›Adds timeout setting for all model backends to cap inference wait time.
v0.2.43 Apr 9, 2025 · issue -367

camel-ai v0.2.43 adds Exa search, crawl4ai, Google Calendar toolkit, Together/Azure embeddings, PPIO LLM, and Llama 4 via OpenRouter.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.43 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.43
```
- ›Adds Exa search integration as a new toolkit for web search capabilities.
- ›Integrates crawl4ai for AI-powered web crawling support.
- ›Adds GoogleCalendarToolkit for interacting with Google Calendar from agents.
- ›Adds Together embedding support as a new embedding backend.
- ›Adds Azure embedding support as a new embedding backend.
+3 moreshow less
- ›Adds PPIO as a new LLM provider platform.
- ›Adds Llama 4 model support via the OpenRouter integration.
- ›Implements Tic Tac Toe as a MultiStepEnv environment for reinforcement-learning-style agent tasks.
v0.2.42 Apr 6, 2025 · issue -367

camel-ai v0.2.42 adds dict-of-strings input to the step function and enhances the terminal toolkit.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.42 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.42
```
- ›Allows a dict of strings to be passed as input to the step function, enabling richer structured message passing to agents.
- ›Enhances the terminal toolkit with new capabilities for agent-driven shell interactions.
v0.2.40 Apr 3, 2025 · issue -367

camel-ai v0.2.40 adds ModelScope integration, YAML/JSON model config loading, MCP server support, and new data-generation verifiers
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.40 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.40
```
└──▷ USE IT
Send a direct message to the user from within a tool-using agent, rather than routing output through the agent reply chain.
python
```
from camel.toolkits import HumanToolkit

toolkit = HumanToolkit()
toolkit.send_message_to_user('Task complete — results saved to output.csv')
```
- ›Supports loading model configs from YAML and JSON files via SaranshPandya's implementation, enabling file-driven model configuration.
- ›Adds send_message_to_user method to human_toolkit for direct user messaging from agent workflows.
- ›Allows optional output dimension parameter in OpenAI-compatible embedding calls.
- ›Integrates ModelScope models as a new model provider in camel.
- ›Adds a self-instruct data generator for synthetic instruction dataset creation.
+4 moreshow less
- ›Adds math verification as a new verifier (math verify) for evaluating model outputs against mathematical reference answers.
- ›Exposes camel toolkits as an MCP server, making them accessible over the Model Context Protocol.
- ›Supports one-command-line connection to MCP servers.
- ›Implements resetting from a generative dataset in reinforcement-learning environments.
└──▷ BREAKING ON UPGRADE
- !The ground_truth field in verifier is renamed to reference_answer — any code passing ground_truth to a verifier will break.
v0.2.38 Mar 28, 2025 · issue -368

camel-ai v0.2.38 adds Evol-Instruct datagen, TiDB vector storage, SearXNG toolkit, OpenAI Responses API, and model request timeouts
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.38 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.38
```
- ›Adds timeout support for the base model backend, enabling callers to bound inference request duration.
- ›Adds SearXNG toolkit for privacy-respecting federated web search inside agent workflows.
- ›Adds OpenAI Responses API support to the model backend.
- ›Adds Evol-Instruct-style data augmentation methods to camel/datagen for synthetic instruction generation.
- ›Adds browser toolkit support with pre-defined dynamic channel routing.
v0.2.37 Mar 25, 2025 · issue -368

camel-ai v0.2.37 adds a Think Toolkit, a GitHub repo query agent, and Gemini 2.5 Pro support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.37 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.37
```
- ›Adds ThinkToolkit for structured reasoning steps within agent workflows.
- ›Adds a new agent for processing queries grounded in GitHub repositories.
- ›Adds support for Gemini 2.5 Pro as a model backend.
v0.2.36 Mar 21, 2025 · issue -368

camel-ai v0.2.36 adds Mem0 memory integration, OpenRouter support, browser downloads, and MCP toolkit header acceptance.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.36 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.36
```
- ›Adds accepting header support in MCP toolkits, enabling custom HTTP headers when connecting to MCP tool servers.
- ›Integrates Mem0 as a memory backend, giving agents persistent, external memory via the Mem0 service.
- ›Adds OpenRouter as a supported model provider, expanding the set of LLM backends available to agents.
- ›Adds browser download capability to the browser toolkit, allowing agents to trigger and handle file downloads.
v0.2.35 Mar 20, 2025 · issue -368

camel-ai v0.2.35 adds persistent agent memory by ID and a pluggable chunker module for custom chunking strategies.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.35 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.35
```
- ›Adds a chunker module enabling custom chunking strategies for document processing pipelines.
- ›Links memory to agents by ID, enabling persistent and retrievable memory scoped to individual agent instances.
v0.2.34 Mar 18, 2025 · issue -368

camel-ai v0.2.34 adds JSONL-based StaticDataset initialization and enhances FewShotGenerator
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.34 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.34
```
- ›Adds JSONL initialization support to StaticDataset, enabling datasets to be loaded directly from JSONL files.
- ›Enhances FewShotGenerator with new capabilities for few-shot example generation.
v0.2.31 Mar 15, 2025 · issue -368

camel-ai v0.2.31 adds Bing Search integration
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.31 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.31
```
- ›Adds Bing Search as a new search backend
v0.2.30 Mar 15, 2025 · issue -368

camel-ai v0.2.30 adds Baidu search integration, enhanced BrowserToolkit, file logging output, and refactored environment types.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.30 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.30
```
- ›Adds Baidu search as a new search integration via feat: add baidu search.
- ›Enhances BrowserToolkit with new capabilities for browser-based agent workflows.
- ›Adds file output support for logging, enabling log persistence to disk.
- ›Refactors BaseEnvironment into distinct SingleStep and MultiStep environment classes for cleaner agent environment modeling.
└──▷ BREAKING ON UPGRADE
- !BaseEnvironment has been refactored into SingleStep and MultiStep environment classes — code importing or subclassing BaseEnvironment directly will break on upgrade.
v0.2.29 Mar 13, 2025 · issue -368

camel-ai v0.2.29 splits datasets into StaticDataset and GenerativeDataset and adds agent tool call try/except handling.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.29 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.29
```
- ›Introduces StaticDataset and GenerativeDataset as distinct classes, replacing the previous unified dataset abstraction.
- ›Adds try/except error handling for agent tool calls, plus updated image logging support.
v0.2.28 Mar 13, 2025 · issue -368

camel-ai v0.2.28 adds MCPToolkitManager for orchestrating multiple MCPToolkits in a single agent.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.28 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.28
```
- ›Adds MCPToolkitManager class to manage multiple MCPToolkit instances together, simplifying multi-toolkit agent setups.
v0.2.27 Mar 12, 2025 · issue -368

camel-ai v0.2.27 adds Volcano Engine model integration and Bocha search to the search toolkit.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.27 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.27
```
- ›Adds Bocha search as a new provider in the search toolkit.
- ›Adds Volcano Engine integration support for model backends.
v0.2.26 Mar 11, 2025 · issue -368

camel-ai v0.2.26 adds Claude tool calling, PubMed toolkit, and dynamic graph support via Neo4j
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.26 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.26
```
- ›Adds Claude tool calling support, enabling Anthropic Claude models to invoke tools through the camel-ai agent framework.
- ›Adds PubMedToolkit to the toolkit collection, allowing agents to query PubMed biomedical literature.
- ›Supports dynamic graph construction via Neo4j, enabling agents to build and query knowledge graphs at runtime.
- ›Refactors SeedDataset to improve compatibility and simplify usage when constructing training datasets.
v0.2.25 Mar 11, 2025 · issue -368

camel-ai v0.2.25 adds function call support in SGLang.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.25 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.25
```
- ›Adds function call support in SGLang.
v0.2.24 Mar 10, 2025 · issue -368

camel-ai v0.2.24 adds Terminal, File Write, and MCP Client toolkits plus Claude 3.7 and async RolePlaying support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.24 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.24
```
└──▷ USE IT
Give an agent the ability to run shell commands and write files in a single session.
python
```
from camel.toolkits import TerminalToolkit, FileWriteToolkit

terminal = TerminalToolkit()
file_writer = FileWriteToolkit()

# Pass both toolkits to your agent
tools = terminal.get_tools() + file_writer.get_tools()
```
- ›Adds TerminalToolkit for agent-driven shell command execution.
- ›Adds FileWriteToolkit for agent-driven file write operations.
- ›Integrates MCP (Model Context Protocol) client as a callable Toolkit, enabling agents to connect to MCP servers.
- ›Adds Claude 3.7 model support via updated Anthropic model config.
- ›Enables RolePlaying to run asynchronously with async support.
v0.2.23 Mar 9, 2025 · issue -368

camel-ai v0.2.23 adds new toolkits (Excel, audio, web, image analysis, Zapier), hybrid retrieval, verifiers, and data-gen pipeline improvements.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.23 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.23
```
└──▷ USE IT
Equip an agent with the ExcelToolkit to read and manipulate spreadsheets during a task.
python
```
from camel.toolkits import ExcelToolkit
from camel.agents import ChatAgent

toolkit = ExcelToolkit()
agent = ChatAgent(tools=toolkit.get_tools())
agent.step('Summarize the data in report.xlsx')
```
- ›Adds stop_on_first_failure option to InstructionFilter in the datagen module to halt pipelines on the first failed instruction.
- ›Adds ensure_ascii option to SelfImprovingCoTPipeline JSON output for non-ASCII character handling in generated datasets.
- ›Adds timestamp to VectorDBMemory to prevent data retrieval order confusion.
- ›Adds ExcelToolkit for agent interaction with Excel files.
- ›Adds WebToolkit (ported from owl project) for web interaction capabilities.
+15 moreshow less
- ›Adds audio toolkit (ported from owl project) for audio processing in agents.
- ›Adds image analysis toolkit for visual analysis tasks.
- ›Integrates Zapier AI as a new toolkit, enabling agents to trigger Zapier workflows.
- ›Adds reasoning_parameter integration for model calls, exposing reasoning configuration to agents.
- ›Introduces BaseVerifier and PythonVerifier for verifying agent-generated code and outputs.
- ›Implements KnowNo for agent uncertainty quantification and conformal prediction.
- ›Adds hybrid retrieval support, combining multiple retrieval strategies in the RAG pipeline.
- ›Integrates NetworkX for graph-based reasoning and data representation.
- ›Adds custom prompt support in the graph agent.
- ›Adds new timeout functionality across all toolkits, enabling per-toolkit execution time limits.
- ›Adds support for the gpt-4.5 model.
- ›Adds Ollama multimodal model support.
- ›Adds rejection sampling data generation pipeline with SelfImprovingCoT pipeline.
- ›Adds logging for error handling and instruction generation progress in datagen pipelines.
- ›Switches dependency management to uv.
v0.2.22 Feb 15, 2025 · issue -369

camel-ai v0.2.22 adds MinerU document extraction and non-ASCII JSON readability in SelfInstructPipeline
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.22 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.22
```
- ›Adds MinerU Extractor for document extraction support.
- ›Enhances SelfInstructPipeline JSON dump to preserve non-ASCII characters in readable form (instead of escaped Unicode sequences).
- ›Adds URL handling support to OpenAIEmbedding to align behavior with OpenAIModel.
v0.2.20 Feb 9, 2025 · issue -369

camel v0.2.20 adds Moonshot, SiliconFlow, and AIML model integrations plus SemanticScholar and SymPy toolkits
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.20 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.20
```
- ›Adds SemanticScholarToolkits to integrate Semantic Scholar academic search into agents.
- ›Integrates Moonshot models into camel's model platform support.
- ›Integrates SiliconFlow model platform.
- ›Integrates AIML model platform.
- ›Adds SymPy integration for symbolic mathematics computation within agents.
+3 moreshow less
- ›Implements STaR (Self-Taught Reasoner) self-improving reasoning pipeline.
- ›Adds internal deduplication support for data pipelines.
- ›Supports Gemini 2.0 Flash Thinking and Gemini 2.0 Pro models.
v0.2.19 Jan 31, 2025 · issue -370

camel-ai v0.2.19 adds Jina embeddings, OpenAI o3-mini support, and tool calling for SGLang and Groq
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.19 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.19
```
- ›Adds support for OpenAI o3-mini model.
- ›Adds Jina embedding integration.
- ›Enables tool calling for SGLang and Groq backends.
- ›Enhances source2synth data synthesis pipeline.
v0.2.18 Jan 22, 2025 · issue -370

camel-ai v0.2.18 adds DeepSeek R1 reasoning content support, a new DeepSeek Reasoner model, and native tool calls for SambaCloud and TogetherAI.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.18 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.18
```
- ›Supports extracting reasoning content from DeepSeek R1 model responses via the model backend.
- ›Adds deepseek_reasoner model to the supported model list.
- ›Enables native tool call support for SambaCloud and TogetherAI providers.
v0.2.17 Jan 19, 2025 · issue -370

camel-ai v0.2.17 adds Discord OAuth, InternLM models, Skywork reward model, Source2Synth, and a structured document loader.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.17 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.17
```
- ›Adds Discord OAuth Flow integration, enabling agent workflows to authenticate with Discord.
- ›Integrates InternLM models as a supported model backend.
- ›Adds Skywork reward model support for scoring and evaluating agent outputs.
- ›Adds Source2Synth for synthetic data generation from source material.
- ›Adds a structured document loader via feat: structured loader for ingesting structured data into agent pipelines.
+2 moreshow less
- ›Adds free proxies option to the Google Scholar Toolkit to work around access restrictions.
- ›Updates function call result message format for tool-calling responses.
v0.2.16 Jan 3, 2025 · issue -370

camel-ai v0.2.16 adds the Dappier toolkit for real-time AI-powered data access.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.16 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.16
```
- ›Adds DappierToolkit integration, enabling agents to query Dappier's real-time data and AI recommendations API.
v0.2.15 Jan 2, 2025 · issue -370

camel-ai v0.2.15 adds graph sampling via Neo4j, OpenBB and Linkup integrations, new benchmarks, native structured output, and a self-instruct pipeline.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.15 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.15
```
- ›Adds native structured output property to ChatAgent, enabling schema-enforced responses without post-processing.
- ›Adds graph sampling support with Neo4j integration for graph-based retrieval workflows.
- ›Adds time-label support to the NebulaGraph integration.
- ›Integrates Linkup as a new data-source provider.
- ›Integrates OpenBB into the library for financial data access within agentic workflows.
+4 moreshow less
- ›Adds benchmarks API-Bank, APIBench, and Nexus to the benchmarks API.
- ›Adds a preliminary self-instruct pipeline for automated instruction-data generation.
- ›Refactors ChatAgent internals (PR #1142).
- ›Adds the o1datagen (CoTDataGenerator) core pipeline for chain-of-thought data generation.
v0.2.14 Dec 18, 2024 · issue -371

camel-ai v0.2.14 adds an Outlines converter model for structured output and support for the OpenAI O1 model.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.14 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.14
```
- ›Adds OutlinesConverter model for structured output generation via the Outlines integration.
- ›Supports the OpenAI O1 model.
v0.2.12 Dec 13, 2024 · issue -371

camel-ai v0.2.12 adds Brave Search, SGLang, e2b, Stripe, reward models, structured outputs, and HuggingFace dataset upload.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.12 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.12
```
- ›Adds structured output support for ChatAgent using the OpenAI beta client, enabling typed response schemas from chat interactions.
- ›Adds structured output support for Ollama models, enabling schema-constrained responses from locally hosted Ollama instances.
- ›Integrates the Brave Web Search API into the search toolkit, giving agents a new web-search backend.
- ›Integrates SGLang as a new inference backend in CAMEL.
- ›Integrates e2b as a new code execution/sandbox backend.
+6 moreshow less
- ›Integrates Stripe as a new toolkit, enabling agents to interact with payment workflows.
- ›Adds a reward model component for scoring and evaluating agent outputs.
- ›Adds a data collector for dataset generation pipelines.
- ›Adds a pipeline to fetch and upload data to HuggingFace datasets.
- ›Adds the llama3.3_70B model to the supported model registry.
- ›Adds the GAIA benchmark for evaluating agent capabilities.
v0.2.11 Dec 4, 2024 · issue -371

camel-ai v0.2.11 adds ModelManager scheduling, NVIDIA platform support, Meshy 3D integration, and structured output improvements.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.11 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.11
```
└──▷ USE IT
Convert a prompt-response pair into a validated Alpaca training record for fine-tuning dataset construction.
python
```
from camel.data_collector import AlpacaItem

item = AlpacaItem(instruction='Explain XSS', input='', output='Cross-site scripting is...')
print(item.model_dump())
```
- ›Adds ModelManager class to schedule and load-balance calls across multiple model backends.
- ›Adds NVIDIA model platform support, expanding available backends alongside existing OpenAI/Azure/Mistral integrations.
- ›Adds logprobs handling in choice response objects, enabling access to token-level log probabilities from model completions.
- ›Adds AlpacaItem pydantic class for easy conversion, validation, and structured Alpaca-format output generation.
- ›Supports OpenAI structured output as a typed object, enabling schema-validated responses from OpenAI models.
+5 moreshow less
- ›Expands CodeExecutionToolkit with additional interpreter backends beyond the existing default.
- ›Integrates Meshy text-to-3D model generation as a new toolkit, allowing agents to produce 3D models from text prompts.
- ›Adds structured logging support throughout the library.
- ›Allows manual addition of filename metadata to documents, with normalized extra metadata fields.
- ›Removes api_keys_required constraint for Firecrawl integration to support self-hosted deployments.
v0.2.10 Nov 28, 2024 · issue -372

CAMEL v0.2.10 adds Persona Hub, Runtime tool execution, video reading, DeepSeek/Cohere/Gemini model support, and OpenAI structured output.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.10 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.10
```
- ›Adds support for OpenAI structured output via camel, enabling agents to receive typed, schema-conforming responses.
- ›Adds Runtime abstraction for tool calling, providing a dedicated execution layer for agent tool invocations.
- ›Adds HumanToolkit for human-in-the-loop interaction with agents.
- ›Supports setting default model and platform from environment variables, removing the need to hardcode model configuration.
- ›Integrates Persona Hub techniques for enhanced agent diversity when generating synthetic agent personas.
+10 moreshow less
- ›Adds ShareGPT conversation format conversion for exporting agent dialogues.
- ›Supports Text to BaseModel parsing, converting raw text output into structured Pydantic BaseModel instances.
- ›Adds OpenAI-compatible embedding support.
- ›Integrates video reading capability for agents to process video content.
- ›Integrates Cohere models as a supported model platform.
- ›Adds support for DeepSeek models.
- ›Adds support for Gemini-Exp-1114 model and updates Gemini implementation with OpenAI compatibility.
- ›Adds qwq model and additional Qwen models to supported model list.
- ›Wolfram Alpha toolkit now records SBSHintStep info in step-by-step results.
- ›Synthesizes execution of tool calling to provide unified tool-call handling across agent workflows.
v0.2.7 Nov 10, 2024 · issue -372

camel-ai v0.2.7 adds Notion, Apify, Tavily, GitHub, and Data Commons toolkits plus 01 and Qwen model platform support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.7 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.7
```
└──▷ USE IT
Pass custom metadata or payload fields through the vector retrieval pipeline using the new extra_payload parameter.
python
```
retriever.process(content="https://example.com/doc", extra_payload={"source": "internal", "priority": 1})
```
- ›Adds extra_payload parameter to VectorRetriever.process() for passing additional data through the retrieval pipeline.
- ›Adds author assignment support to the Google Scholar toolkit.
- ›New Notion toolkit integration for reading and writing Notion content from agents.
- ›New Apify toolkit integration for running Apify actors from agent workflows.
- ›New Tavily search toolkit integration for web search inside agents.
+7 moreshow less
- ›New GitHub toolkit with GitHub functions for interacting with repositories from agents.
- ›New Data Commons toolkit for querying the Google Data Commons knowledge graph.
- ›Adds support for the 01 model platform.
- ›Adds support for the Qwen model platform.
- ›Adds OpenAI tool schema generation capability.
- ›Qdrant vector store enhancements.
- ›WolframAlpha toolkit now returns more detailed output.
v0.2.3 Oct 22, 2024 · issue -373

camel-ai v0.2.3 adds WhatsApp, Discord, Slack, Arxiv, Google Scholar, AskNews, and Chunkr integrations plus FunctionTool refactor
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.3 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.3
```
└──▷ USE IT
Drop system_message to spin up a minimal ChatAgent without boilerplate role definition.
python
```
from camel.agents import ChatAgent

agent = ChatAgent()  # system_message now optional
response = agent.step('Summarize the latest AI news')
print(response.msg.content)
```
Wrap a plain Python function as a FunctionTool (formerly OpenAIFunction) and attach it to an agent.
python
```
from camel.toolkits import FunctionTool
from camel.agents import ChatAgent

def get_weather(city: str) -> str:
    return f'Sunny in {city}'

tool = FunctionTool(get_weather)
agent = ChatAgent(tools=[tool])
response = agent.step('What is the weather in Paris?')
print(response.msg.content)
```
- ›Renames OpenAIFunction to FunctionTool, providing a unified interface for defining callable tools across agents.
- ›Makes system_message optional in ChatAgent, reducing boilerplate for minimal agent setups.
- ›Adds ChatAgent interface enhancements and a configurable default model setting.
- ›New ArxivToolkit for querying and retrieving academic papers from arXiv.
- ›New GoogleScholarToolkit for searching Google Scholar from within agents.
+7 moreshow less
- ›New AskNewsToolkit for fetching live news context inside agent workflows.
- ›Integrates WhatsApp messaging as a new toolkit for agent-driven communication.
- ›Integrates Discord as a new app toolkit, enabling agents to interact with Discord channels.
- ›Integrates Slack as a new app toolkit, enabling agents to interact with Slack workspaces.
- ›Integrates Chunkr for document chunking and processing workflows.
- ›Adds Mistral ministral-3b and ministral-8b model support.
- ›Adds AgentOps observability support for SambaNova-hosted models.
└──▷ BREAKING ON UPGRADE
- !The model parameter in ModelFactory is renamed to model_type; any code passing model= as a keyword argument will break.
v0.2.2 Oct 10, 2024 · issue -373

camel-ai v0.2.2 adds Llama tool calling, Nebula Graph integration, Mistral Pixtral support, and bytes handling for vector retrieval.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.2 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.2
```
- ›Adds tool calling support for Llama models.
- ›Adds Nebula Graph integration for graph-based storage and retrieval.
- ›Supports the Mistral Pixtral multimodal model.
- ›Adds support for handling bytes input in vector retrieval.
v0.1.7.0 Sep 9, 2024 · issue -374

camel-ai v0.1.7.0 adds object storage, five new model/platform integrations, LinkedIn and Reddit toolkits, and richer RAG controls.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.7.0 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.1.7.0
```
└──▷ USE IT
Tune retrieval precision in an agent by setting how many chunks to return and a minimum similarity cutoff.
python
```
from camel.toolkits import RetrievalToolkit

toolkit = RetrievalToolkit(
    top_k=5,
    similarity_threshold=0.75,
)
```
Point camel-ai at any OpenAI-compatible local or third-party endpoint without a custom model class.
python
```
from camel.models import OpenAICompatibilityModel

model = OpenAICompatibilityModel(
    model_type="llama3",
    url="http://localhost:11434/v1",
    api_key="none",
)
```
- ›Adds top_k and similarity_threshold parameters to RetrievalToolkit for fine-grained retrieval tuning.
- ›Adds max_characters setting to RAG to cap chunk size during ingestion.
- ›Adds subprocess-based local serving support for Ollama and vllm via the new subprocess integration.
- ›Adds firecrawl map endpoint support for broader web-crawl coverage.
- ›Adds OpenAICompatibilityModel to support any OpenAI-compatible model endpoint as a drop-in backend.
+10 moreshow less
- ›Integrates Together AI as a supported model platform.
- ›Integrates SambaNova model and SambaVerse API as supported model platforms.
- ›Integrates Reka model as a supported model platform.
- ›Integrates Mistral tool-calling support alongside a Mistral version update.
- ›Adds LinkedIn toolkit for agent-driven LinkedIn interactions.
- ›Adds Reddit toolkit for agent-driven Reddit interactions.
- ›Rebuilds RecordMemory module with updated architecture.
- ›Adds object storage support for storing and retrieving agent artifacts.
- ›Enables AutoRetriever to accept raw strings and Element objects as input (previously required pre-processed documents).
- ›Updates auto_retriever output format for improved downstream parsing.
v0.1.6.1 Aug 7, 2024 · issue -375

camel-ai v0.1.6.1 adds Workforce orchestration, Task primitives, Firecrawl integration, multi-modal DALL-E support, and structured function-call responses.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.6.1 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.1.6.1
```
- ›Adds Task class to camel, providing a first-class primitive for defining and managing agent tasks.
- ›Adds Workforce class for orchestrating multiple agents working together on a shared workload.
- ›Integrates Firecrawl as a new tool, enabling agents to crawl and extract web content.
- ›Adds AgentOps observability settings, allowing configuration of AgentOps tracking for agent runs.
- ›Supports structured responses via function calls, enabling agents to return typed, schema-constrained output.
+1 moreshow less
- ›Supports multi-modal input and multi-modal output (including DALL-E image generation) within a single agent.
v0.1.6.0 Jul 30, 2024 · issue -376

camel-ai v0.1.6.0 adds Gemini 1.5, vLLM, Azure OpenAI, Mistral, Groq-hosted Llama 3/Gemma, GPT-4o Mini, and an IPython kernel code interpreter.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.6.0 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.1.6.0
```
- ›Adds GPT_4O_MINI model constant for targeting OpenAI's GPT-4o Mini in agents and role-playing sessions.
- ›Supports custom token counters via ModelFactory, letting callers override the default counter at construction time.
- ›Adds Azure OpenAI API as a model backend, enabling agents to route requests through Azure-hosted OpenAI endpoints.
- ›Supports vLLM as a model backend for self-hosted, high-throughput inference.
- ›Integrates Gemini 1.5 as a supported model backend.
+4 moreshow less
- ›Integrates Mistral AI as a supported model backend.
- ›Integrates Groq-hosted Llama 3 (8B and 70B), Mistral.AI, and Gemma (7B and 9B) as model backends via the Groq service.
- ›Adds an IPython kernel code interpreter, enabling agents to execute code interactively in an IPython session.
- ›Moves tool functions into a dedicated toolkits directory, providing a cleaner import path for agent toolkits.
v0.1.5.5 Jul 6, 2024 · issue -376

camel-ai v0.1.5.5 adds Claude 3.5, Redis cache, Docker code execution, Jina Reader, and async utilities
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.5.5 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.1.5.5
```
- ›Adds Redis cache storage backend for agent memory and caching workflows.
- ›Supports internal_python code interpreter as a callable tool, enabling agents to execute code directly.
- ›Adds Docker-based code execution sandbox for isolated, safe code running.
- ›Integrates Jina Reader into the loaders API for web content ingestion.
- ›Adds a config file mechanism for models using the OpenAI-compatible interface.
+5 moreshow less
- ›Adds utility functions to convert synchronous functions to async functions.
- ›Adds Claude 3.5 model support.
- ›Adds new open-source models to the supported model list.
- ›Adds a Discord bot with RAG (retrieval-augmented generation) capability.
- ›Updates sentence transformer and OpenAI text embedding integrations.
v0.1.5.3 Jun 21, 2024 · issue -377

camel-ai v0.1.5.3 adds async ChatAgent, VLM embeddings, DuckDuckGo search, Discord/Telegram bots, LiteLLM, Nemotron, ZhipuAI, and GitHub PR retrieval.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.5.3 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.1.5.3
```
- ›Integrates VLM (Vision-Language Model) embedding model support.
- ›Adds DuckDuckGo search and enhanced text extraction from websites.
- ›Adds API key support for OpenAPI functions.
- ›Adds more OpenAPI functions and refactors open_api_function.
- ›Adds Discord bot integration.
+7 moreshow less
- ›Adds Telegram bot integration.
- ›Adds support for the LiteLLM library as a model backend.
- ›Integrates Nemotron API as a supported model provider.
- ›Adds ZhipuAI model support.
- ›Adds retrieve recent pull requests capability to GithubToolkit.
- ›Adds video description function into agent capabilities.
- ›Makes Slack SDK dependency optional.