LangManus: Revolutionizing AI Automation with Multi-Agent Systems

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

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

LangManus's Fully Automated Plan and Solution:

1. Gather the latest information about "DeepSeek R1", "HuggingFace", and related topics through online searches.
2. Interact with a Chromium instance to visit the HuggingFace official website, search for "DeepSeek R1" and retrieve the latest data, including followers, likes, downloads, and other relevant metrics.
3. Find formulas for calculating model influence using search engines and web scraping.
4. Use Python to compute the influence index of DeepSeek R1 based on the collected data.
5. Present a comprehensive report to the user.

View on YouTube

Project Statement

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

Tools and Integrations

Development Features

Workflow Management

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-layer LLM system, which are respectively used for reasoning, basic tasks, and vision-language tasks. Configuration is done using the conf.yaml file in the root directory of the project. You can copy conf.yaml.example to conf.yaml to start the configuration:

cp conf.yaml.example conf.yaml

# Setting it to true will read the conf.yaml configuration, and setting it to false will use the original .env configuration. The default is false (compatible with existing configurations)
USE_CONF: true

# LLM Config
## Follow the litellm configuration parameters: https://docs.litellm.ai/docs/providers. You can click on the specific provider document to view the completion parameter examples
REASONING_MODEL:
  model: "volcengine/ep-xxxx"
  api_key: $REASONING_API_KEY # Supports referencing the environment variable ENV_KEY in the.env file through $ENV_KEY
  api_base: $REASONING_BASE_URL

BASIC_MODEL:
  model: "azure/gpt-4o-2024-08-06"
  api_base: $AZURE_API_BASE
  api_version: $AZURE_API_VERSION
  api_key: $AZURE_API_KEY

VISION_MODEL:
  model: "azure/gpt-4o-2024-08-06"
  api_base: $AZURE_API_BASE
  api_version: $AZURE_API_VERSION
  api_key: $AZURE_API_KEY

You can create a .env file in the root directory of the project and configure the following environment variables. You can copy the.env.example file as a template to start:

cp .env.example .env

# Tool API Key
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, the path to the Chrome executable file
CHROME_HEADLESS=False  # Optional, the default is False
CHROME_PROXY_SERVER=http://127.0.0.1:10809  # Optional, the default is None
CHROME_PROXY_USERNAME=  # Optional, the default is None
CHROME_PROXY_PASSWORD=  # Optional, the default is None

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

Agent Prompts System

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

Core Agent Roles

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.

Docker Compose (include both backend and frontend)

LangManus provides a docker-compose setup to easily run both the backend and frontend together:

# Start both backend and frontend
docker-compose up -d

# The backend will be available at http://localhost:8000
# The frontend will be available at http://localhost:3000, which could be accessed through web browser

This will:

1. Build and start the LangManus backend container
2. Build and start the LangManus web UI container
3. Connect them using a shared network

** Make sure you have your .env file prepared with the necessary API keys before starting the services. **

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

Workflow Visualization

LangManus provides a visual representation of its multi-agent workflow using Mermaid diagrams:

graph TD A[User Input] --> B[Coordinator] B --> C[Planner] C --> D[Supervisor] D --> E[Researcher] D --> F[Coder] D --> G[Browser] D --> H[File Manager] E --> I[Web Search] E --> J[Data Analysis] F --> K[Code Execution] F --> L[Package Management] G --> M[Web Navigation] G --> N[Content Extraction] H --> O[File Operations] I & J & K & L & M & N & O --> P[Reporter] P --> Q[Final Output]

FAQ

Q: What makes LangManus different from other AI frameworks?

A: LangManus stands out with its hierarchical multi-agent architecture, deep integration with open source tools, and focus on practical automation tasks. Unlike many frameworks that focus on a single LLM, LangManus coordinates specialized agents with different capabilities to solve complex problems.

Q: What types of tasks is LangManus best suited for?

A: LangManus excels at tasks requiring multiple steps and different capabilities, such as:

• Research tasks requiring information gathering and analysis
• Data processing workflows that combine web scraping and code execution
• Automation of complex workflows that would normally require human intervention
• Tasks requiring both natural language understanding and technical execution

Q: How can I contribute to LangManus?

A: We welcome contributions of all kinds! Please see our Contributing Guide for details on how to get started. You can contribute by:

• Submitting bug reports or feature requests through GitHub issues
• Improving documentation
• Adding new features or fixing bugs through pull requests
• Sharing your experiences and use cases with the community

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.

Star History

Acknowledgments

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

This project is inspired by and builds upon the work of:

• Qwen - For their incredible open source language models
• LangChain - For pioneering work in LLM application frameworks
• LangGraph - For their graph-based approach to LLM orchestration
• TaskWeaver - For their innovative work in task planning
• uv - For their lightning-fast Python package manager

Explore LangManus on GitHub