git clone https://github.com/xingyaoww/code-act
cd code-act
pip install -r requirements.txt

docker run -d –name manus-sandbox \
  -v $(pwd)/workspace:/home/ubuntu \
  –cap-drop=ALL \
  ubuntu:latest

apt-get update && apt-get install -y \
  python3 python3-pip nodejs npm 
  curl wget git
pip install playwright selenium beautifulsoup4
playwright install

# agent_tools.py
import subprocess
import requests
from playwright.sync_api import sync_playwright

def search_web(query):
    # SerpAPI 등 사용
    response = requests.get(f"https://serpapi.com/search?q={query}&api_key={API_KEY}")
    return response.json()

def browse_url(url):
    with sync_playwright() as p:
        browser = p.chromium.launch()
        page = browser.new_page()
        page.goto(url)
        content = page.content()
        browser.close()
    return content

def execute_python(code):
    # 안전한 실행 환경 생성
    result = subprocess.run(
        ["python3", "-c", code],
        capture_output=True,
        text=True
    )
    return result.stdout, result.stderr

def shell_command(cmd):
    # 안전한 명령만 허용
    safe_cmds = ["ls", "cat", "echo", "mkdir", "touch"]
    cmd_base = cmd.split()[0]
    if cmd_base not in safe_cmds:
        return f"Command {cmd_base} not allowed"
    
    result = subprocess.run(
        cmd, shell=True, capture_output=True, text=True
    )
    return result.stdout, result.stderr

# agent_loop.py
from langchain.chains import LLMChain
from langchain.prompts.chat import ChatPromptTemplate
from langchain.llms import HuggingFacePipeline
import json

# CodeActAgent 모델 로드
model = HuggingFacePipeline.from_model_id(
    model_id="xingyaoww/CodeActAgent-Mistral-7B",
    task="text-generation",
    model_kwargs={"temperature": 0.1}
)

def agent_loop(user_request):
    # 컨텍스트 초기화
    event_stream = [{"type": "user", "content": user_request}]
    
    # 계획 생성
    plan = create_plan(user_request)
    event_stream.append({"type": "plan", "content": plan})
    
    # 워크스페이스 초기화
    workspace = {"files": {}, "todo": plan}
    
    # 메인 루프
    while True:
        # 모델에 전달할 컨텍스트 준비
        context = format_context(event_stream, workspace)
        
        # 모델로부터 다음 액션 받기
        response = model(context)
        
        # 응답에서 코드 추출
        code = extract_code_from_response(response)
        
        if "TASK_COMPLETE" in code:
            # 최종 결과 반환
            return workspace["files"].get("output.md", "Task completed")
        
        # 코드 실행 및 결과 캡처
        result, error = safe_execute_code(code)
        
        # 이벤트 스트림에 추가
        event_stream.append({"type": "action", "content": code})
        event_stream.append({"type": "observation", "content": result or error})
        
        # 코드 실행 결과로 워크스페이스 업데이트
        update_workspace(workspace, code, result)

def update_workspace(workspace, code, result):
    """코드 실행 결과로 워크스페이스 업데이트"""
    # 코드에서 파일 작업 추출
    if "write_file(" in code:
        # 파일 작업 파싱
        filename = extract_filename(code)
        content = extract_content(code)
        workspace["files"][filename] = content
    
    # todo.md 추적 업데이트
    if "update_todo(" in code:
        step_number = extract_step_number(code)
        workspace["todo"] = mark_step_complete(workspace["todo"], step_number)

from langchain.vectorstores import FAISS
from langchain.embeddings import HuggingFaceEmbeddings

# 임베딩 모델 초기화
embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")

def retrieve_knowledge(query, documents):
    """현재 작업에 필요한 지식 검색"""
    # 문서로부터 벡터스토어 생성
    vectorstore = FAISS.from_documents(documents, embeddings)
    
    # 관련 내용 검색
    docs = vectorstore.similarity_search(query, k=3)
    
    return [doc.page_content for doc in docs]

SYSTEM_PROMPT = """
You are an autonomous AI agent that can use tools to accomplish tasks.

<agent_capabilities>
- Execute Python code
- Access the web through search and browsing
- Read and write files
- Run shell commands
</agent_capabilities>

<tool_use_rules>
1. Always respond with Python code that uses the provided agent_tools functions
2. One action per response
3. Never try to access prohibited tools or APIs
4. Check results of each action before proceeding
</tool_use_rules>

<planning_approach>
1. Break down complex tasks into steps
2. Track progress in todo.md
3. Update todo.md as steps are completed
4. Use results from prior steps to inform later steps
</planning_approach>

<error_handling>
1. If an action fails, diagnose the error
2. Try alternative approaches when blocked
3. After 3 failed attempts, move to a different approach
</error_handling>

<information_rules>
1. Prioritize authoritative sources
2. Cross-check information across multiple sources 
3. Cite sources in final output
4. Never make up information
</information_rules>

You have access to these tools:
- agent_tools.search_web(query): Search the web
- agent_tools.browse_url(url): Get content of a webpage
- agent_tools.execute_python(code): Run Python code
- agent_tools.shell_command(cmd): Run safe shell commands
- write_file(filename, content): Save information to a file
- read_file(filename): Retrieve content from a file
- update_todo(step_number, status): Update task status

Your goal is to complete the assigned task completely and accurately.
"""

import gradio as gr

def process_request(user_input):
    # 세션 초기화 또는 이어서 진행
    result = agent_loop(user_input)
    return result

# 간단한 웹 UI 생성
with gr.Blocks() as demo:
    chatbot = gr.Chatbot()
    msg = gr.Textbox()
    clear = gr.Button("Clear")
    
    def respond(message, chat_history):
        bot_message = process_request(message)
        chat_history.append((message, bot_message))
        return "", chat_history
    
    msg.submit(respond, [msg, chatbot], [msg, chatbot])
    clear.click(lambda: None, None, chatbot, queue=False)

demo.launch()

from crewai import Agent, Task, Crew

# 전문화된 에이전트 생성
researcher = Agent(
    role="Researcher",
    goal="Find accurate information",
    backstory="You're an expert at finding information",
    llm=model
)

coder = Agent(
    role="Coder",
    goal="Write efficient code",
    backstory="You're an expert Python programmer",
    llm=model
)

# 에이전트별 작업 생성
research_task = Task(
    description="Find information about X",
    agent=researcher
)

coding_task = Task(
    description="Implement functionality for X",
    agent=coder
)

# 에이전트 크루 생성
crew = Crew(
    agents=[researcher, coder],
    tasks=[research_task, coding_task],
    verbose=True
)

# 크루 실행
result = crew.kickoff()

def interact_with_webpage(url, actions):
    """웹페이지에서 액션 수행"""
    with sync_playwright() as p:
        browser = p.chromium.launch()
        page = browser.new_page()
        page.goto(url)
        
        for action in actions:
            if action["type"] == "click":
                page.click(action["selector"])
            elif action["type"] == "fill":
                page.fill(action["selector"], action["value"])
            elif action["type"] == "submit":
                page.evaluate(f"document.querySelector('{action['selector']}').submit()")
        
        content = page.content()
        browser.close()
    return content

# docker-compose.yml
version: '3'
services:
  manus-replica:
    build: .
    ports:
      - "8000:8000"
    volumes:
      - ./data:/app/data
    restart: always
    environment:
      - MODEL_PATH=/app/models/CodeActAgent
      - API_KEYS={"serpapi": "your_key_here"}