LangManus

English | 简体中文

Come From Open Source, Back to Open Source

LangManus is a community-driven AI automation framework that builds upon the incredible work of the open source community. Our goal is to combine language models with specialized tools for tasks like web search, crawling, and Python code execution, while giving back to the community that made this possible.

Demo Video

Task: Calculate the influence index of DeepSeek R1 on HuggingFace. This index can be designed by considering a weighted sum of factors such as followers, downloads, and likes.

• View on YouTube
• Download Video

Table of Contents

• Quick Start
• Project Statement
• Architecture
• Features
• Why LangManus?
• Setup
  • Prerequisites
  • Installation
  • Configuration
• Usage
• Docker
• Web UI
• Development
• Contributing
• License
• Acknowledgments

Quick Start

# Clone the repository
git clone https://github.com/langmanus/langmanus.git
cd langmanus

# Install dependencies, uv will take care of the python interpreter and venv creation
uv sync

# Playwright install to use Chromium for browser-use by default
uv run playwright install

# Configure environment
cp .env.example .env
# Edit .env with your API keys

# Run the project
uv run main.py

Project Statement

This is an academically driven open-source project, developed by a group of former colleagues in our spare time. It aims to explore and exchange ideas in the fields of Multi-Agent and DeepResearch.

• Purpose: The primary purpose of this project is academic research, participation in the GAIA leaderboard, and the future publication of related papers.
• Independence Statement: This project is entirely independent and unrelated to our primary job responsibilities. It does not represent the views or positions of our employers or any organizations.
• No Association: This project has no association with Manus (whether it refers to a company, organization, or any other entity).
• Clarification Statement: We have not promoted this project on any social media platforms. Any inaccurate reports related to this project are not aligned with its academic spirit.
• Contribution Management: Issues and PRs will be addressed during our free time and may experience delays. We appreciate your understanding.
• Disclaimer: This project is open-sourced under the MIT License. Users assume all risks associated with its use. We disclaim any responsibility for any direct or indirect consequences arising from the use of this project.

项目声明

本项目是一个学术驱动的开源项目，由一群前同事在业余时间开发，旨在探索和交流 Multi-Agent 和 DeepResearch 相关领域的技术。

• 项目目的：本项目的主要目的是学术研究、参与 GAIA 排行榜，并计划在未来发表相关论文。
• 独立性声明：本项目完全独立，与我们的本职工作无关，不代表我们所在公司或任何组织的立场或观点。
• 无关联声明：本项目与 Manus（无论是公司、组织还是其他实体）无任何关联。
• 澄清声明：我们未在任何社交媒体平台上宣传过本项目，任何与本项目相关的不实报道均与本项目的学术精神无关。
• 贡献管理：Issue 和 PR 将在我们空闲时间处理，可能存在延迟，敬请谅解。
• 免责声明：本项目基于 MIT 协议开源，使用者需自行承担使用风险。我们对因使用本项目产生的任何直接或间接后果不承担责任。

Architecture

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

The system consists of the following agents working together:

1. Coordinator - The entry point that handles initial interactions and routes tasks
2. Planner - Analyzes tasks and creates execution strategies
3. Supervisor - Oversees and manages the execution of other agents
4. Researcher - Gathers and analyzes information
5. Coder - Handles code generation and modifications
6. Browser - Performs web browsing and information retrieval
7. Reporter - Generates reports and summaries of the workflow results

Features

Core Capabilities

• 🤖 LLM Integration
  • Support for open source models like Qwen
  • OpenAI-compatible API interface
  • Multi-tier LLM system for different task complexities

Tools and Integrations

• 🔍 Search and Retrieval
  • Web search via Tavily API
  • Neural search with Jina
  • Advanced content extraction

Development Features

• 🐍 Python Integration
  • Built-in Python REPL
  • Code execution environment
  • Package management with uv

Workflow Management

• 📊 Visualization and Control
  • Workflow graph visualization
  • Multi-agent orchestration
  • Task delegation and monitoring

Why LangManus?

We believe in the power of open source collaboration. This project wouldn't be possible without the amazing work of projects like:

• Qwen for their open source LLMs
• Tavily for search capabilities
• Jina for crawl search technology
• Browser-use for control browser
• And many other open source contributors

We're committed to giving back to the community and welcome contributions of all kinds - whether it's code, documentation, bug reports, or feature suggestions.

Setup

Prerequisites

• uv package manager

Installation

LangManus leverages uv as its package manager to streamline dependency management. Follow the steps below to set up a virtual environment and install the necessary dependencies:

# Step 1: Create and activate a virtual environment through uv
uv python install 3.12
uv venv --python 3.12

source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Step 2: Install project dependencies
uv sync

By completing these steps, you'll ensure your environment is properly configured and ready for development.

Configuration

LangManus uses a three-tier LLM system with separate configurations for reasoning, basic tasks, and vision-language tasks. Create a .env file in the project root and configure the following environment variables:

# Reasoning LLM Configuration (for complex reasoning tasks)
REASONING_MODEL=your_reasoning_model
REASONING_API_KEY=your_reasoning_api_key
REASONING_BASE_URL=your_custom_base_url  # Optional

# Basic LLM Configuration (for simpler tasks)
BASIC_MODEL=your_basic_model
BASIC_API_KEY=your_basic_api_key
BASIC_BASE_URL=your_custom_base_url  # Optional

# Vision-Language LLM Configuration (for tasks involving images)
VL_MODEL=your_vl_model
VL_API_KEY=your_vl_api_key
VL_BASE_URL=your_custom_base_url  # Optional

# Tool API Keys
TAVILY_API_KEY=your_tavily_api_key
JINA_API_KEY=your_jina_api_key  # Optional

# Browser Configuration
CHROME_INSTANCE_PATH=/Applications/Google Chrome.app/Contents/MacOS/Google Chrome  # Optional, path to Chrome executable
CHROME_HEADLESS=False  # Optional, default is False
CHROME_PROXY_SERVER=http://127.0.0.1:10809  # Optional, default is None
CHROME_PROXY_USERNAME=  # Optional, default is None
CHROME_PROXY_PASSWORD=  # Optional, default is None

In addition to supporting LLMs compatible with OpenAI, LangManus also supports Azure LLMs. The configuration method is as follows:

# AZURE LLM Config
AZURE_API_BASE=https://xxxx
AZURE_API_KEY=xxxxx
AZURE_API_VERSION=2023-07-01-preview

# Reasoning LLM (for complex reasoning tasks)
REASONING_AZURE_DEPLOYMENT=xxx

# Non-reasoning LLM (for straightforward tasks)
BASIC_AZURE_DEPLOYMENT=gpt-4o-2024-08-06

# Vision-language LLM (for tasks requiring visual understanding)
VL_AZURE_DEPLOYMENT=gpt-4o-2024-08-06

Note:

• The system uses different models for different types of tasks:
  • Reasoning LLM for complex decision-making and analysis
  • Basic LLM for simpler text-based tasks
  • Vision-Language LLM for tasks involving image understanding
• You can customize the base URLs for all LLMs independently, and you can use LiteLLM's board LLM support by following this guide.
• Each LLM can use different API keys if needed
• Jina API key is optional. Provide your own key to access a higher rate limit (get your API key at jina.ai)
• Tavily search is configured to return a maximum of 5 results by default (get your API key at app.tavily.com)

You can copy the .env.example file as a template to get started:

cp .env.example .env

Configure Pre-commit Hook

LangManus includes a pre-commit hook that runs linting and formatting checks before each commit. To set it up:

1. Make the pre-commit script executable:

chmod +x pre-commit

2. Install the pre-commit hook:

ln -s ../../pre-commit .git/hooks/pre-commit

The pre-commit hook will automatically:

• Run linting checks (make lint)
• Run code formatting (make format)
• Add any reformatted files back to staging
• Prevent commits if there are any linting or formatting errors

Usage

Basic Execution

To run LangManus with default settings:

uv run main.py

API Server

LangManus provides a FastAPI-based API server with streaming support:

# Start the API server
make serve

# Or run directly
uv run server.py

The API server exposes the following endpoints:

• POST /api/chat/stream: Chat endpoint for LangGraph invoke with streaming support
  • Request body:

  {
    "messages": [{ "role": "user", "content": "Your query here" }],
    "debug": false
  }

  • Returns a Server-Sent Events (SSE) stream with the agent's responses

Advanced Configuration

LangManus can be customized through various configuration files in the src/config directory:

• env.py: Configure LLM models, API keys, and base URLs
• tools.py: Adjust tool-specific settings (e.g., Tavily search results limit)
• agents.py: Modify team composition and agent system prompts

Agent Prompts System

LangManus uses a sophisticated prompting system in the src/prompts directory to define agent behaviors and responsibilities:

Core Agent Roles

• Supervisor (src/prompts/supervisor.md): Coordinates the team and delegates tasks by analyzing requests and determining which specialist should handle them. Makes decisions about task completion and workflow transitions.

• Researcher (src/prompts/researcher.md): Specializes in information gathering through web searches and data collection. Uses Tavily search and web crawling capabilities while avoiding mathematical computations or file operations.

• Coder (src/prompts/coder.md): Professional software engineer role focused on Python and bash scripting. Handles:

  • Python code execution and analysis
  • Shell command execution
  • Technical problem-solving and implementation

• File Manager (src/prompts/file_manager.md): Handles all file system operations with a focus on properly formatting and saving content in markdown format.

• Browser (src/prompts/browser.md): Web interaction specialist that handles:

  • Website navigation
  • Page interaction (clicking, typing, scrolling)
  • Content extraction from web pages

Prompt System Architecture

The prompts system uses a template engine (src/prompts/template.py) that:

• Loads role-specific markdown templates
• Handles variable substitution (e.g., current time, team member information)
• Formats system prompts for each agent

Each agent's prompt is defined in a separate markdown file, making it easy to modify behavior and responsibilities without changing the underlying code.

Docker

LangManus can be run in a Docker container. default serve api on port 8000.

Before run docker, you need to prepare environment variables in .env file.

docker build -t langmanus .
docker run --name langmanus -d --env-file .env -e CHROME_HEADLESS=True -p 8000:8000 langmanus

You can also just run the cli with docker.

docker build -t langmanus .
docker run --rm -it --env-file .env -e CHROME_HEADLESS=True langmanus uv run python main.py

Web UI

LangManus provides a default web UI.

Please refer to the langmanus/langmanus-web-ui project for more details.

Development

Testing

Run the test suite:

# Run all tests
make test

# Run specific test file
pytest tests/integration/test_workflow.py

# Run with coverage
make coverage

Code Quality

# Run linting
make lint

# Format code
make format

Contributing

We welcome contributions of all kinds! Whether you're fixing a typo, improving documentation, or adding a new feature, your help is appreciated. Please see our Contributing Guide for details on how to get started.

License

This project is open source and available under the MIT License.

Acknowledgments

Special thanks to all the open source projects and contributors that make LangManus possible. We stand on the shoulders of giants.