6 | {messages.map((message, index) => (
7 |
12 | );
13 | }
14 |
15 | export default ChatDisplay;
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "openmanus",
3 | "version": "0.1.0",
4 | "private": true,
5 | "dependencies": {
6 | "next": "^14.0.0",
7 | "react": "^18.2.0",
8 | "react-dom": "^18.2.0",
9 | "axios": "^1.3.4"
10 | },
11 | "scripts": {
12 | "dev": "next dev",
13 | "build": "next build",
14 | "start": "next start",
15 | "lint": "next lint"
16 | }
17 | }
--------------------------------------------------------------------------------
/src/tools/server.py:
--------------------------------------------------------------------------------
1 | from flask import Flask, request, jsonify
2 | import logging
3 |
4 | app = Flask(__name__)
5 | logging.basicConfig(level=logging.INFO)
6 | logger = logging.getLogger(__name__)
7 |
8 | @app.route('/health', methods=['GET'])
9 | def health_check():
10 | return jsonify({'status': 'ok'})
11 |
12 | if __name__ == '__main__':
13 | app.run(host='0.0.0.0', port=5001)
--------------------------------------------------------------------------------
/docker/unified/start.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 | # Start FastAPI server in background
4 | PYTHONPATH=/app:/app/src python3 -m uvicorn src.server:app --host 0.0.0.0 --port 8000 --reload &
5 |
6 | # Start tools server in background
7 | PYTHONPATH=/app:/app/src python3 src/tools/server.py &
8 |
9 | # Wait for all background processes to complete
10 | wait
11 |
12 | # Exit with the status of the last command
13 | exit $?
--------------------------------------------------------------------------------
/src/tools/browser.py:
--------------------------------------------------------------------------------
1 | from langchain.tools import BaseTool
2 |
3 | class BrowserTool(BaseTool):
4 | name: str = "browser"
5 | description: str = "Placeholder browser tool"
6 |
7 | def _run(self, instruction: str) -> str:
8 | return "Browser tool placeholder"
9 |
10 | async def _arun(self, instruction: str) -> str:
11 | return "Browser tool placeholder"
12 |
13 | browser_tool = BrowserTool()
--------------------------------------------------------------------------------
/docker-compose.yml:
--------------------------------------------------------------------------------
1 | version: '3.8'
2 |
3 | services:
4 | unified:
5 | build:
6 | context: .
7 | dockerfile: docker/unified/Dockerfile
8 | ports:
9 | - "8000:8000"
10 | environment:
11 | - PYTHONPATH=/app
12 | - FLASK_APP=src/server.py
13 | - FLASK_ENV=development
14 |
15 | frontend:
16 | build:
17 | context: .
18 | dockerfile: docker/frontend/Dockerfile
19 | ports:
20 | - "3000:3000"
21 | depends_on:
22 | - unified
--------------------------------------------------------------------------------
/src/tools/search.py:
--------------------------------------------------------------------------------
1 | import logging
2 | import logging
3 | from src.tools.browser import browser_tool # Import the existing browser tool
4 | from .decorators import create_logged_tool
5 |
6 | logger = logging.getLogger(__name__)
7 |
8 | # Initialize Bing search tool using browser tool with logging
9 | LoggedBrowserSearch = create_logged_tool(browser_tool.__class__) # Use the class of browser_tool
10 | bing_tool = LoggedBrowserSearch(name="bing_search", description="Search Bing using a headless browser.") # Updated name and description
--------------------------------------------------------------------------------
/src/agents/coder_agent.py:
--------------------------------------------------------------------------------
1 | from typing import List
2 | from langchain_core.messages import BaseMessage
3 |
4 | from src.llms.llm import get_llm_by_type
5 | from src.config.agents import AGENT_LLM_MAP
6 |
7 | class CoderAgent:
8 | """Coder agent that handles code-related tasks."""
9 |
10 | def invoke(self, messages: List[BaseMessage]) -> BaseMessage:
11 | """Process the messages and return a response."""
12 | llm = get_llm_by_type(AGENT_LLM_MAP["coder"])
13 | return llm.invoke(messages)
14 |
15 | coder_agent = CoderAgent()
--------------------------------------------------------------------------------
/src/config/agents.py:
--------------------------------------------------------------------------------
1 | from typing import Literal
2 |
3 | # Define available LLM types
4 | LLMType = Literal["basic", "reasoning", "vision"]
5 |
6 | # Define agent-LLM mapping
7 | AGENT_LLM_MAP: dict[str, LLMType] = {
8 | "coordinator": "basic", # 协调默认使用basic llm
9 | "planner": "reasoning", # 计划默认使用basic llm
10 | "supervisor": "basic", # 决策使用basic llm
11 | "researcher": "basic", # 简单搜索任务使用basic llm
12 | "coder": "basic", # 编程任务使用basic llm
13 | "browser": "vision", # 浏览器操作使用vision llm
14 | "reporter": "basic", # 编写报告使用basic llm
15 | }
--------------------------------------------------------------------------------
/src/agents/browser_agent.py:
--------------------------------------------------------------------------------
1 | from typing import List
2 | from langchain_core.messages import BaseMessage
3 |
4 | from src.llms.llm import get_llm_by_type
5 | from src.config.agents import AGENT_LLM_MAP
6 |
7 | class BrowserAgent:
8 | """Browser agent that handles web browsing tasks."""
9 |
10 | def invoke(self, messages: List[BaseMessage]) -> BaseMessage:
11 | """Process the messages and return a response."""
12 | llm = get_llm_by_type(AGENT_LLM_MAP["browser"])
13 | return llm.invoke(messages)
14 |
15 | browser_agent = BrowserAgent()
--------------------------------------------------------------------------------
/src/agents/reporter_agent.py:
--------------------------------------------------------------------------------
1 | from typing import List
2 | from langchain_core.messages import BaseMessage
3 |
4 | from src.llms.llm import get_llm_by_type
5 | from src.config.agents import AGENT_LLM_MAP
6 |
7 | class ReporterAgent:
8 | """Reporter agent that handles report generation tasks."""
9 |
10 | def invoke(self, messages: List[BaseMessage]) -> BaseMessage:
11 | """Process the messages and return a response."""
12 | llm = get_llm_by_type(AGENT_LLM_MAP["reporter"])
13 | return llm.invoke(messages)
14 |
15 | reporter_agent = ReporterAgent()
--------------------------------------------------------------------------------
/src/agents/nodes/types.py:
--------------------------------------------------------------------------------
1 | from typing import TypedDict, Literal, List, Dict, Any
2 | from langchain_core.messages import BaseMessage
3 |
4 | class State(TypedDict):
5 | """Type definition for the workflow state."""
6 | messages: List[BaseMessage]
7 | full_plan: str
8 | next: str
9 | deep_thinking_mode: bool
10 | search_before_planning: bool
11 |
12 | class Router(TypedDict):
13 | """Type definition for the supervisor's routing decision."""
14 | next: Literal['coordinator', 'planner', 'supervisor', 'researcher', 'coder', 'browser', 'reporter', 'FINISH']
--------------------------------------------------------------------------------
/src/agents/research_agent.py:
--------------------------------------------------------------------------------
1 | from typing import List
2 | from langchain_core.messages import BaseMessage
3 |
4 | from src.llms.llm import get_llm_by_type
5 | from src.config.agents import AGENT_LLM_MAP
6 |
7 | class ResearchAgent:
8 | """Research agent that handles research and information gathering tasks."""
9 |
10 | def invoke(self, messages: List[BaseMessage]) -> BaseMessage:
11 | """Process the messages and return a response."""
12 | llm = get_llm_by_type(AGENT_LLM_MAP["researcher"])
13 | return llm.invoke(messages)
14 |
15 | research_agent = ResearchAgent()
--------------------------------------------------------------------------------
/src/tools/decorators.py:
--------------------------------------------------------------------------------
1 | import logging
2 | import functools
3 | from typing import Any, Callable, Type, TypeVar
4 |
5 | logger = logging.getLogger(__name__)
6 |
7 | T = TypeVar("T")
8 |
9 | def log_io(func: Callable) -> Callable:
10 | @functools.wraps(func)
11 | def wrapper(*args: Any, **kwargs: Any) -> Any:
12 | return func(*args, **kwargs)
13 | return wrapper
14 |
15 | class LoggedToolMixin:
16 | def _run(self, *args: Any, **kwargs: Any) -> Any:
17 | return super()._run(*args, **kwargs)
18 |
19 | def create_logged_tool(base_tool_class: Type[T]) -> Type[T]:
20 | class LoggedTool(LoggedToolMixin, base_tool_class):
21 | pass
22 | return LoggedTool
--------------------------------------------------------------------------------
/src/graph/types.py:
--------------------------------------------------------------------------------
1 | from typing import Literal
2 | from typing_extensions import TypedDict
3 | from langgraph.graph import MessagesState
4 |
5 | from src.config import TEAM_MEMBERS
6 |
7 | # Define routing options
8 | OPTIONS = TEAM_MEMBERS + ["FINISH"]
9 |
10 |
11 | class Router(TypedDict):
12 | """Worker to route to next. If no workers needed, route to FINISH."""
13 |
14 | next: Literal[OPTIONS[0], OPTIONS[1], OPTIONS[2], OPTIONS[3], "FINISH"]
15 |
16 |
17 | class State(MessagesState):
18 | """State for the agent system, extends MessagesState with next field."""
19 |
20 | # Constants
21 | TEAM_MEMBERS: list[str]
22 |
23 | # Runtime Variables
24 | next: str
25 | full_plan: str
26 | deep_thinking_mode: bool
27 | search_before_planning: bool
--------------------------------------------------------------------------------
/src/utils/json_utils.py:
--------------------------------------------------------------------------------
1 | """Utility functions for JSON handling in OpenManus."""
2 |
3 | import json
4 | import json_repair
5 |
6 | def repair_json_output(json_str: str) -> str:
7 | """Repair malformed JSON strings.
8 |
9 | Args:
10 | json_str: The potentially malformed JSON string to repair.
11 |
12 | Returns:
13 | str: A valid JSON string.
14 | """
15 | try:
16 | # First try to parse as-is
17 | json.loads(json_str)
18 | return json_str
19 | except json.JSONDecodeError:
20 | # If parsing fails, attempt repair
21 | try:
22 | return json_repair.repair_json(json_str)
23 | except Exception as e:
24 | # If repair fails, return original string
25 | return json_str
--------------------------------------------------------------------------------
/src/tools/crawl.py:
--------------------------------------------------------------------------------
1 | import logging
2 | from typing import Annotated
3 |
4 | from langchain_core.messages import HumanMessage
5 | from langchain_core.tools import tool
6 | from .decorators import log_io
7 |
8 | from src.crawler import Crawler
9 |
10 | logger = logging.getLogger(__name__)
11 |
12 |
13 | @tool
14 | @log_io
15 | def crawl_tool(
16 | url: Annotated[str, "The url to crawl."],
17 | ) -> HumanMessage:
18 | """Use this to crawl a url and get a readable content in markdown format."""
19 | try:
20 | crawler = Crawler()
21 | article = crawler.crawl(url)
22 | return {"role": "user", "content": article.to_message()}
23 | except BaseException as e:
24 | error_msg = f"Failed to crawl. Error: {repr(e)}"
25 | logger.error(error_msg)
26 | return error_msg
--------------------------------------------------------------------------------
/src/client.py:
--------------------------------------------------------------------------------
1 | import argparse
2 | import requests
3 | import json
4 |
5 | def submit_task(task, host="http://localhost:5000"):
6 | """Submit a task to the agent server."""
7 | try:
8 | response = requests.post(f"{host}/task", json={"task": task})
9 | response.raise_for_status()
10 | return response.json()
11 | except requests.exceptions.RequestException as e:
12 | return {"error": str(e)}
13 |
14 | def main():
15 | parser = argparse.ArgumentParser(description="OpenManus CLI Client")
16 | parser.add_argument("--task", required=True, help="Task description")
17 | parser.add_argument("--host", default="http://localhost:5000", help="Agent server host")
18 |
19 | args = parser.parse_args()
20 |
21 | result = submit_task(args.task, args.host)
22 | print(json.dumps(result, indent=2))
23 |
24 | if __name__ == "__main__":
25 | main()
--------------------------------------------------------------------------------
/src/pages/index.js:
--------------------------------------------------------------------------------
1 | import ChatInput from '../components/ChatInput';
2 | import ChatDisplay from '../components/ChatDisplay';
3 | import React, { useState } from 'react';
4 |
5 | function HomePage() {
6 | const [messages, setMessages] = useState([]);
7 |
8 | const handleSendMessage = (newMessage) => {
9 | setMessages([...messages, { sender: 'user', text: newMessage }]);
10 | // Here you would typically send the message to the backend and handle the response
11 | // For now, let's just add a placeholder response from the AI
12 | setTimeout(() => {
13 | setMessages([...messages, { sender: 'ai', text: 'This is a placeholder response from the AI.' }]);
14 | }, 500); // Simulate a delay for AI response
15 | };
16 |
17 | return (
18 |
8 | {message.sender}: {message.text}
9 |
10 | ))}
11 |
19 |
23 | );
24 | }
25 |
26 | export default HomePage;
--------------------------------------------------------------------------------
/src/tools/python_repl.py:
--------------------------------------------------------------------------------
1 | import logging
2 | from typing import Annotated
3 | from langchain_core.tools import tool
4 | from langchain_experimental.utilities import PythonREPL
5 | from .decorators import log_io
6 |
7 | # Initialize REPL and logger
8 | repl = PythonREPL()
9 | logger = logging.getLogger(__name__)
10 |
11 |
12 | @tool
13 | @log_io
14 | def python_repl_tool(
15 | code: Annotated[
16 | str, "The python code to execute to do further analysis or calculation."
17 | ],
18 | ):
19 | """Use this to execute python code and do data analysis or calculation. If you want to see the output of a value,
20 | you should print it out with `print(...)`. This is visible to the user."""
21 | logger.info("Executing Python code")
22 | try:
23 | result = repl.run(code)
24 | logger.info("Code execution successful")
25 | except BaseException as e:
26 | error_msg = f"Failed to execute. Error: {repr(e)}"
27 | logger.error(error_msg)
28 | return error_msg
29 | result_str = f"Successfully executed:\\n```python\\n{code}\\n```\\nStdout: {result}"
30 | return result_str
--------------------------------------------------------------------------------
/src/agents/nodes/browser_node.py:
--------------------------------------------------------------------------------
1 | import logging
2 | import json_repair
3 | from typing import Literal, Dict, Any
4 | from langchain_core.messages import HumanMessage
5 |
6 | from src.agents import browser_agent # Import browser agent
7 | from src.utils.json_utils import repair_json_output
8 | from .types import State # Import State type
9 |
10 | logger = logging.getLogger(__name__)
11 |
12 | def browser_node(state: State) -> Dict[str, Any]: # Modified return type to Dict
13 | """Node for the browser agent that performs web browsing tasks."""
14 | logger.info("Browser agent starting task")
15 | result = browser_agent.invoke(state)
16 | logger.info("Browser agent completed task")
17 | response_content = result["messages"][-1].content
18 | response_content = repair_json_output(response_content)
19 | logger.debug(f"Browser agent response: {response_content}")
20 | return Command(
21 | update={
22 | "messages": [
23 | HumanMessage(
24 | content=response_content,
25 | name="browser",
26 | )
27 | ]
28 | },
29 | goto="supervisor",
30 | )
--------------------------------------------------------------------------------
/src/agents/nodes/coder_node.py:
--------------------------------------------------------------------------------
1 | import logging
2 | import json_repair
3 | from typing import Literal, Dict, Any
4 | from langchain_core.messages import HumanMessage
5 | from langgraph.types import Command
6 |
7 | from src.agents import coder_agent # Import coder agent
8 | from src.utils.json_utils import repair_json_output
9 | from .types import State # Import State type
10 |
11 | logger = logging.getLogger(__name__)
12 |
13 | def coder_node(state: State) -> Dict[str, Any]: # Modified return type to Dict
14 | """Node for the coder agent that executes Python code."""
15 | logger.info("Code agent starting task")
16 | result = coder_agent.invoke(state)
17 | logger.info("Code agent completed task")
18 | response_content = result["messages"][-1].content
19 | response_content = repair_json_output(response_content)
20 | logger.debug(f"Code agent response: {response_content}")
21 | return Command(
22 | update={
23 | "messages": [
24 | HumanMessage(
25 | content=response_content,
26 | name="coder",
27 | )
28 | ]
29 | },
30 | goto="supervisor",
31 | )
--------------------------------------------------------------------------------
/src/agents/nodes/researcher_node.py:
--------------------------------------------------------------------------------
1 | import logging
2 | import json_repair
3 | from typing import Literal, Dict, Any
4 | from langchain_core.messages import HumanMessage
5 | from langgraph.types import Command
6 |
7 | from src.agents import research_agent # Import researcher agent
8 | from src.utils.json_utils import repair_json_output
9 | from .types import State # Import State type
10 |
11 | logger = logging.getLogger(__name__)
12 |
13 | def researcher_node(state: State) -> Dict[str, Any]: # Modified return type to Dict
14 | """Node for the researcher agent that performs research tasks."""
15 | logger.info("Research agent starting task")
16 | result = research_agent.invoke(state)
17 | logger.info("Research agent completed task")
18 | response_content = result["messages"][-1].content
19 | response_content = repair_json_output(response_content)
20 | logger.debug(f"Research agent response: {response_content}")
21 | return Command(
22 | update={
23 | "messages": [
24 | HumanMessage(
25 | content=response_content,
26 | name="researcher",
27 | )
28 | ]
29 | },
30 | goto="supervisor",
31 | )
--------------------------------------------------------------------------------
/src/service/workflow_service.py:
--------------------------------------------------------------------------------
1 | """Workflow service for managing agent workflow execution."""
2 |
3 | import asyncio
4 | from typing import AsyncGenerator, Dict, List
5 |
6 | from src.workflow.graph import build_graph
7 | from src.prompts.template import OpenManusPromptTemplate
8 |
9 |
10 | async def run_agent_workflow(
11 | messages: List[Dict[str, str]], debug: bool = False
12 | ) -> AsyncGenerator[Dict[str, str], None]:
13 | """Run the agent workflow with the given messages.
14 |
15 | Args:
16 | messages: List of chat messages
17 | debug: Whether to enable debug logging
18 |
19 | Yields:
20 | Event data for SSE streaming
21 | """
22 | # Initialize workflow graph
23 | workflow = build_graph()
24 |
25 | # Format messages with system prompt
26 | formatted_messages = OpenManusPromptTemplate.apply_prompt_template(
27 | "coordinator", {"messages": messages}
28 | )
29 |
30 | # Run workflow
31 | async for event in workflow.astream({"messages": formatted_messages}):
32 | yield {
33 | "event": "message",
34 | "data": {"content": event.get("content", ""), "role": "assistant"}
35 | }
36 | # Small delay to avoid overwhelming the client
37 | await asyncio.sleep(0.1)
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | This is free and unencumbered software released into the public domain.
2 |
3 | Anyone is free to copy, modify, publish, use, compile, sell, or
4 | distribute this software, either in source code form or as a compiled
5 | binary, for any purpose, commercial or non-commercial, and by any
6 | means.
7 |
8 | In jurisdictions that recognize copyright laws, the author or authors
9 | of this software dedicate any and all copyright interest in the
10 | software to the public domain. We make this dedication for the benefit
11 | of the public at large and to the detriment of our heirs and
12 | successors. We intend this dedication to be an overt act of
13 | relinquishment in perpetuity of all present and future rights to this
14 | software under copyright law.
15 |
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 |
24 | For more information, please refer to Welcome to OpenManus!
20 |
4 | 
5 |