update mistral example

Author: Wendong-Fan

examples/mcp_servers_config.json

@@ -2,8 +2,10 @@
   "mcpServers": {
     "playwright": {
       "command": "npx",
-      "args": ["-y", "@executeautomation/playwright-mcp-server"]
+      "args": [
+        "@playwright/mcp@latest"
+      ]
     }
   }
-}
+}   
 

examples/run_mistral.py

@@ -11,25 +11,83 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+"""MCP Multi-Agent System Example
+
+This example demonstrates how to use MCP (Model Context Protocol) with CAMEL agents
+for advanced information retrieval and processing tasks.
+
+Environment Setup:
+1. Configure the required dependencies of owl library
+   Refer to: https://github.com/camel-ai/owl for installation guide
+
+2. MCP Server Setup:
+
+
+   2.1 MCP Playwright Service:
+   ```bash
+   # Install MCP service
+   npm install -g @executeautomation/playwright-mcp-server
+   npx playwright install-deps
+
+   # Configure in mcp_servers_config.json:
+   {
+     "mcpServers": {
+       "playwright": {
+         "command": "npx",
+         "args": ["-y", "@executeautomation/playwright-mcp-server"]
+       }
+     }
+   }
+   ```
+
+   2.2 MCP Fetch Service (Optional - for better retrieval):
+   ```bash
+   # Install MCP service
+   pip install mcp-server-fetch
+
+   # Configure in mcp_servers_config.json:
+   {
+     "mcpServers": {
+       "fetch": {
+         "command": "python",
+         "args": ["-m", "mcp_server_fetch"]
+       }
+     }
+   }
+   ```
+
+Usage:
+1. Ensure all MCP servers are properly configured in mcp_servers_config.json
+2. Run this script to create a multi-agent system that can:
+   - Access and manipulate files through MCP Desktop Commander
+   - Perform web automation tasks using Playwright
+   - Process and generate information using Mistral
+   - Fetch web content (if fetch service is configured)
+3. The system will execute the specified task while maintaining security through
+   controlled access
+
+Note:
+- All file operations are restricted to configured directories
+- Supports asynchronous operations for efficient processing
+"""
+
+import asyncio
 import sys
-import pathlib
+from pathlib import Path
+from typing import List
+
 from dotenv import load_dotenv
+
 from camel.models import ModelFactory
-from camel.toolkits import (
-    AudioAnalysisToolkit,
-    CodeExecutionToolkit,
-    ExcelToolkit,
-    ImageAnalysisToolkit,
-    SearchToolkit,
-    VideoAnalysisToolkit,
-    BrowserToolkit,
-    FileWriteToolkit,
-)
+from camel.toolkits import FunctionTool
 from camel.types import ModelPlatformType, ModelType
 from camel.logger import set_log_level
+from camel.toolkits import MCPToolkit
 from camel.societies import RolePlaying
 
-from owl.utils import run_society, DocumentProcessingToolkit
+from owl.utils.enhanced_role_playing import arun_society
+
+import pathlib
 
 base_dir = pathlib.Path(__file__).parent.parent
 env_path = base_dir / "owl" / ".env"
@@ -38,17 +96,16 @@
 set_log_level(level="DEBUG")
 
 
-def construct_society(question: str) -> RolePlaying:
-    r"""Construct a society of agents based on Mistral model(s).
+async def construct_society(
+    question: str,
+    tools: List[FunctionTool],
+) -> RolePlaying:
+    r"""build a multi-agent RolePlaying instance.
 
     Args:
-        question (str): The task or question to be addressed by the society.
-
-    Returns:
-        RolePlaying: A configured society of agents ready to address the question.
+        question (str): The question to ask.
+        tools (List[FunctionTool]): The MCP tools to use.
     """
-
-    # Create models for different components
     models = {
         "user": ModelFactory.create(
             model_platform=ModelPlatformType.MISTRAL,
@@ -60,89 +117,60 @@ def construct_society(question: str) -> RolePlaying:
             model_type=ModelType.MISTRAL_LARGE,
             model_config_dict={"temperature": 0},
         ),
-        "browsing": ModelFactory.create(
-            model_platform=ModelPlatformType.MISTRAL,
-            model_type=ModelType.MISTRAL_LARGE,
-            model_config_dict={"temperature": 0},
-        ),
-        "planning": ModelFactory.create(
-            model_platform=ModelPlatformType.MISTRAL,
-            model_type=ModelType.MISTRAL_LARGE,
-            model_config_dict={"temperature": 0},
-        ),
-        "video": ModelFactory.create(
-            model_platform=ModelPlatformType.MISTRAL,
-            model_type=ModelType.MISTRAL_PIXTRAL_12B,
-            model_config_dict={"temperature": 0},
-        ),
-        "image": ModelFactory.create(
-            model_platform=ModelPlatformType.MISTRAL,
-            model_type=ModelType.MISTRAL_PIXTRAL_12B,
-            model_config_dict={"temperature": 0},
-        ),
-        "document": ModelFactory.create(
-            model_platform=ModelPlatformType.MISTRAL,
-            model_type=ModelType.MISTRAL_LARGE,
-            model_config_dict={"temperature": 0},
-        ),
     }
 
-    # Configure toolkits
-    tools = [
-        *BrowserToolkit(
-            headless=True,
-            web_agent_model=models["browsing"],
-            planning_agent_model=models["planning"],
-        ).get_tools(),
-        *VideoAnalysisToolkit(model=models["video"]).get_tools(),
-        *AudioAnalysisToolkit().get_tools(),
-        *CodeExecutionToolkit(sandbox="subprocess", verbose=True).get_tools(),
-        *ImageAnalysisToolkit(model=models["image"]).get_tools(),
-        SearchToolkit().search_duckduckgo,
-        SearchToolkit().search_google,
-        SearchToolkit().search_wiki,
-        *ExcelToolkit().get_tools(),
-        *DocumentProcessingToolkit(model=models["document"]).get_tools(),
-        *FileWriteToolkit(output_dir="./").get_tools(),
-    ]
-
-    # Configure agent roles and parameters
     user_agent_kwargs = {"model": models["user"]}
-    assistant_agent_kwargs = {"model": models["assistant"], "tools": tools}
+    assistant_agent_kwargs = {
+        "model": models["assistant"],
+        "tools": tools,
+    }
 
-    # Configure task parameters
     task_kwargs = {
         "task_prompt": question,
         "with_task_specify": False,
     }
 
-    # Create and return the society
     society = RolePlaying(
         **task_kwargs,
         user_role_name="user",
         user_agent_kwargs=user_agent_kwargs,
         assistant_role_name="assistant",
         assistant_agent_kwargs=assistant_agent_kwargs,
     )
-
     return society
 
 
-def main():
-    r"""Main function to run the OWL system with an example question."""
-    # Default research question
-    default_task = "Open Brave search, summarize the github stars, fork counts, etc. of camel-ai's camel framework, and write the numbers into a python file using the plot package, save it locally, and run the generated python file. Note: You have been provided with the necessary tools to complete this task."
+async def main():
+    config_path = Path(__file__).parent / "mcp_servers_config.json"
+    mcp_toolkit = MCPToolkit(config_path=str(config_path))
+
+    try:
+        await mcp_toolkit.connect()
+
+        # Default task
+        default_task = (
+            "I'd like a academic report about Andrew Ng, including "
+            "his research direction, published papers (At least 3), "
+            "institutions, etc. You have been provided with tools to do "
+            "browser operation. Open browser to finish the task."
+        )
 
-    # Override default task if command line argument is provided
-    task = sys.argv[1] if len(sys.argv) > 1 else default_task
+        # Override default task if command line argument is provided
+        task = sys.argv[1] if len(sys.argv) > 1 else default_task
 
-    # Construct and run the society
-    society = construct_society(task)
-    answer, chat_history, token_count = run_society(society)
+        # Connect to all MCP toolkits
+        tools = [*mcp_toolkit.get_tools()]
+        society = await construct_society(task, tools)
+        answer, chat_history, token_count = await arun_society(society)
+        print(f"\033[94mAnswer: {answer}\033[0m")
 
-    # Output the result
-    print(f"\033[94mAnswer: {answer}\033[0m")
+    finally:
+        # Make sure to disconnect safely after all operations are completed.
+        try:
+            await mcp_toolkit.disconnect()
+        except Exception:
+            print("Disconnect failed")
 
 
 if __name__ == "__main__":
-    main()
+    asyncio.run(main())

pyproject.toml

@@ -28,6 +28,7 @@ dependencies = [
     "mcp-server-fetch==2025.1.17",
     "xmltodict>=0.14.2",
     "firecrawl>=2.5.3",
+    "mistralai>=1.7.0",
 ]
 
 [project.urls]