DeepManus: The leader in open source multi-agent collaboration

DeepManus is an AI automation framework developed based on LangManus. It supports GPT, DeepSeek, Qwen, etc. as large models, and reduces the use of third-party frameworks, making it easier to use in China. The project is built on the excellent work of the open source community, and its goal is to add "hands and feet" to large models, that is, to make large models more widely used in actual operations and task execution.

Project Background and Objectives

• Background  : With the development of artificial intelligence technology, large models have shown powerful capabilities in areas such as language processing. However, how to better apply these large models to practical scenarios so that they can operate and execute like humans has become an important research direction. DeepManus was born in this context. It hopes to expand the application scope and practicality of large models by combining multiple technologies and tools..

• Objective  : Mainly focus on the application research of large models, give large models practical operational capabilities, enable them to complete more complex tasks, such as data collection, analysis, report generation, code writing and execution, etc., so as to play a role in more fields and improve work efficiency and quality.

Core Features

1. Multi-agent collaborative system  : It adopts a hierarchical multi-agent architecture, including multiple agents such as coordinators, planners, supervisors, researchers, coders, browsers and reporters. They each perform their duties and work together to handle complex tasks. For example, when it is necessary to collect and analyze information on a certain topic and generate a report, the coordinator is responsible for receiving the initial request and distributing the task, the planner formulates the execution strategy, the researcher obtains information through network search and data collection, the coder performs the necessary code writing and data processing, the browser performs web browsing and information retrieval operations, and finally the reporter generates a comprehensive report and summary.

2. Large model integration  : Supports multiple large models, mainly through litellm to support most models, and is compatible with deepseek's API interface, and also supports open source models such as Qwen. This multi-model support architecture enables DeepManus to flexibly call different models according to the needs of different tasks, give full play to the advantages of each model, and improve the processing effect and accuracy of tasks.

3. Search and crawling functions  : With the help of tools such as Tavily API, network search can be realized, and combined with standard scripts and advanced content extraction technology, it can obtain rich information resources from the Internet. This provides DeepManus with powerful information collection capabilities when handling various tasks that require data support, such as market research, news analysis, academic research and other scenarios.

4. Code execution and Python integration  : Built-in Python REPL and code execution environment, and package management through uv, so that DeepManus can directly execute Python code. This means that users can perform various Python-supported operations such as data analysis, scientific computing, machine learning model training, etc. within the framework, greatly enhancing its capabilities in data processing and computing-intensive tasks.

5. Workflow management and visualization  : Provides visualization of workflow diagrams, which can monitor and manage the coordination of multiple agents and task distribution. Users can clearly understand the execution process of tasks and the working status of each agent through the visualization interface, which facilitates the optimization and adjustment of workflows to ensure efficient execution of tasks.

   
   

Architecture

DeepManus implements a hierarchical multi-agent system, where a supervisor agent coordinates specialized agents to accomplish complex tasks:

The system consists of the following agents working together:

1. Coordinator: The entry point of the workflow, handling initial interactions and routing tasks

2. Planner: Analyze tasks and develop execution strategies

3. Supervisor: Oversees and manages the execution of other agents

4. Researcher: Collects and analyzes information

5. Programmer: responsible for code generation and modification

6. Browser: performs web browsing and information retrieval

7. Reporter: Generates reports and summaries of workflow results

   
   

Project code structure

The system architecture of DeepManus mainly consists of the following parts:

• Entry file  : main.py is the entry file of the project. After startup, it will load the configuration and initialize each component, then receive the request message through the server and forward it to MultiAgent for processing.

• Multi-agent system  : Located in the agents folder, it defines multiple agent classes, such as coordinator, planner, supervisor, etc. Each agent has its specific functions and responsibilities, and completes complex tasks through collaboration.

• Configuration management system  : The config folder contains various configuration files of the project, such as env.py, tools.py, agents.py, etc., which are used to configure large models, API keys, basic URLs, tool-specific settings, agent team composition, and system prompts.

• Prompts system  : The prompts folder is the core of DeepManus's prompt system. Each agent's role and behavior are defined through a separate Markdown file. The template engine is used to load the markdown template, handle variable substitution, and format the system prompts to control the agent's operation logic..

• Toolset  : The tools folder contains various tools used in the project, such as network tools, code tools, file tools, browser tools, etc. These tools provide specific operational capabilities for the agent, enabling it to interact with the external environment and perform tasks.

• Server component  : The server.py file implements the server function of the project, built on FastAPI, provides services such as chat interface, supports communication with other systems or clients, and enables DeepManus to be called and integrated as a server-side application.

  
  

Quick Start

• Clone the repository  : Use the Git command to clone the DeepManus code repository locally.

• Install dependencies  : Run the uv sync command to install the dependency packages required by the project.

• Install Playwright  : Execute the uv run playwright install command to install Playwright so that you can use Chromium for browser operations.

• Configure the environment  : Copy the .env.example file and rename it to .env, then fill in the relevant configuration information such as the API key in the .env file.

• Run the project  : Start the DeepManus project by executing the uv run main.py command.

How to use

• Basic execution  : You can run DeepManus directly with the default settings, send requests to it through the command line or other clients, and let the agent perform the corresponding tasks.

• API Server  : DeepManus provides an API Server based on FastAPI, which supports streaming responses. You can call LangGraph and get the streaming response of the agent by sending a POST request to the specified API endpoint, such as /api/chat/stream.

• Advanced configuration  : Users can customize various configuration files of the project as needed to meet specific needs, such as adjusting the composition of the agent team, modifying tool settings, optimizing the prompt words of the agent, etc.

Advantages and Features

• Open source collaboration  : Based on the concept of the open source community, DeepManus has absorbed the experience and technology of many excellent open source projects, such as LangChain, LangGraph, Browser-use, etc., and is also open source itself, encouraging community contributions and collaboration to continuously promote the improvement and development of the project.

• Easy to use in China  : Compared with some other similar frameworks, DeepManus reduces its dependence on third-party frameworks and can more conveniently obtain and use related resources in China, lowering the threshold for deployment and use in the domestic environment.

• Powerful functional integration  : It integrates multiple functions such as large models, network search, data collection, code execution, etc., which can meet the automation task requirements in various complex scenarios and provide users with personalized solutions.

Related projects and supporting tools

• DeepManus-web  : This is a supporting front-end project for DeepManus, which provides users with a more friendly web interface to interact with DeepManus. Through this front-end interface, users can more conveniently send requests, view results, manage tasks, etc., which improves the project's ease of use and user experience.

Application Scenario

• Data analysis and report generation  : It can automatically collect relevant data, analyze and process it, and generate detailed reports, which are suitable for market research, industry analysis, academic research and other fields.

• Automated testing  : It can simulate user operations and perform automated testing on software or websites to improve testing efficiency and coverage.

• Content creation  : By calling upon the power of the big model, it assists in content creation work such as article writing, copywriting generation, and creative conception.

• Scientific research  : Help researchers collect literature, analyze experimental data, perform scientific calculations, etc., to accelerate the progress of scientific research.

• Educational guidance  : Provide students with personalized learning guidance, such as answering questions, correcting homework, generating learning materials, etc.