Upload 13 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+AWorld-main/aworlddistributed/img.png filter=lfs diff=lfs merge=lfs -text

AWorld-main/aworlddistributed/.dockerignore

@@ -0,0 +1,11 @@
+.venv
+.env
+.git
+.gitignore
+.github
+Dockerfile
+examples
+docs
+*.md
+dev.sh
+dev-docker.sh

AWorld-main/aworlddistributed/.env_examples

@@ -0,0 +1,28 @@
+# Development settings
+LOG_FILE_PATH="aworldserver.log"
+
+FILESYSTEM_SERVER_WORKDIR=""
+
+## LLM
+LLM_PROVIDER=""
+LLM_BASE_URL=""
+LLM_API_KEY=""
+
+## TAVILY
+TAVILY_API_KEY="xxx"
+
+
+AUDIO_LLM_API_KEY=""
+AUDIO_LLM_BASE_URL=""
+AUDIO_LLM_MODEL_NAME=""
+
+GOOGLE_API_KEY=""
+GOOGLE_SEARCH_ENGINE_ID=""
+GOOGLE_CSE_ID=""
+
+E2B_API_KEY=""
+
+APIFY_API_TOKEN=""
+
+AMAP_API_KEY=""
+START_TRACE_SERVER="true"

AWorld-main/aworlddistributed/.gitignore

@@ -0,0 +1,16 @@
+__pycache__
+.env
+
+/litellm
+
+pipelines/*
+!pipelines/.gitignore
+.DS_Store
+datasets/gaia_dataset/**
+task_logs/**/*
+task_logs/result/**/*
+
+aworldspace/agents/**/*.json
+
+.venv
+venv/

AWorld-main/aworlddistributed/Dockerfile

@@ -0,0 +1,76 @@
+FROM python:3.11-slim-bookworm AS base
+
+
+## Basis ##
+ENV ENV=prod \
+    PORT=9099
+
+# Install GCC and build tools. 
+# These are kept in the final image to enable installing packages on the fly.
+RUN apt-get update && \
+    apt-get install -y gcc build-essential curl git && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN apt-get update && apt-get install -y wget unzip openssh-client procps nodejs npm
+
+ARG PIP_OPTIONS='-i https://mirrors.aliyun.com/pypi/simple/'
+ARG ENABLE_OSS_MOUNT=""
+
+RUN pip install -U pip pysocks ${PIP_OPTIONS}
+
+# Install Chrome Driver
+RUN mkdir /app
+
+RUN cd /app/ && \
+    wget https://storage.googleapis.com/chrome-for-testing-public/136.0.7103.92/linux64/chromedriver-linux64.zip && \
+    unzip chromedriver-linux64.zip && \
+    rm chromedriver-linux64.zip
+ENV CHROME_DRIVER_PATH=/app/chromedriver-linux64/chromedriver
+
+
+RUN if [ "$ENABLE_OSS_MOUNT" = "true" ]; then \
+        apt-get update && \
+        apt-get install -y gdebi-core mime-support && \
+        cd /tmp && \
+        wget https://gosspublic.alicdn.com/ossfs/ossfs_1.91.6_ubuntu22.04_amd64.deb && \
+        gdebi ossfs_1.91.6_ubuntu22.04_amd64.deb -n && \
+        rm ossfs_1.91.6_ubuntu22.04_amd64.deb && \
+        apt-get clean && \
+        rm -rf /var/lib/apt/lists/*; \
+    fi
+
+FROM base as runner
+
+WORKDIR /app
+
+# Install Python dependencies
+COPY ./requirements.txt .
+RUN pip3 install uv ${PIP_OPTIONS}
+RUN uv pip install --system -r requirements.txt --no-cache-dir ${PIP_OPTIONS}
+
+# Copy the application code
+RUN echo "start install aworld"
+RUN mkdir -p /app/lib
+RUN cd /app/lib && git clone https://github.com/inclusionAI/AWorld.git
+RUN cd /app/lib/AWorld && git checkout framework_upgrade_aworldserver_gaia && pip install -r aworld/requirements.txt ${PIP_OPTIONS} && python setup.py install
+
+RUN npx playwright install chrome --with-deps --no-shell
+
+RUN cd /app
+
+
+
+# Layer on for other components
+FROM runner AS app
+
+WORKDIR /app
+
+COPY . .
+
+# Expose the port
+ENV HOST="0.0.0.0"
+ENV PORT="9099"
+
+# if we already installed the requirements on build, we can skip this step on run
+ENTRYPOINT [ "bash", "start.sh" ]

AWorld-main/aworlddistributed/README.md

@@ -0,0 +1,158 @@
+# AworldServer
+
+AworldServer is an execution environment for the Aworld framework that integrates MCP LLM models. It supports distributed deployment and dynamic scaling. 
+
+![img.png](img.png)
+
+The system features:
+
+- Distributed Architecture: Supports multi-server deployment with load balancing
+- Dynamic Scaling: Ability to adjust server capacity based on demand
+- LLM Integration: Built-in MCP LLM model support
+- Asynchronous Processing: Uses asynchronous programming patterns for improved performance
+- Containerized Deployment: Docker containerization support for easy environment management
+
+
+
+## 🚀 Quick Start
+
+1. Start services using Docker Compose:
+
+```sh
+docker build  --build-arg MINIMUM_BUILD=true -f Dockerfile  --progress=plain -t aworldserver:main .
+
+docker compose up -d
+```
+2. Configure the number of server instances:
+
+You can modify the `docker-compose.yaml` file to adjust the number of server instances. The default configuration includes 3 instances:
+
+3. Usage Methods:
+
+   a. OpenWebUI Integration:
+   - Configure external link in OpenWebUI settings
+   - Add AworldServer endpoints to the configuration
+   - Set up API key authentication
+
+   b. Python Client Usage:
+   ```python
+   # Initialize AworldTaskClient with server endpoints
+   AWORLD_TASK_CLIENT = AworldTaskClient(
+       know_hosts=["localhost:9299", "localhost:9399", "localhost:9499"]
+   )
+
+   async def _run_gaia_task(gaia_question_id: str) -> None:
+       """Run a single Gaia task with the given question ID.
+       
+       Args:
+           gaia_question_id: The ID of the question to process
+       """
+       global AWORLD_TASK_CLIENT
+       task_id = str(uuid.uuid4())
+       
+       # Submit task to Aworld server
+       await AWORLD_TASK_CLIENT.submit_task(
+           AworldTask(
+               task_id=task_id,
+               agent_id="gaia_agent",
+               agent_input=gaia_question_id,
+               session_id="session_id",
+               user_id="SYSTEM"
+           )
+       )
+       
+       # Get and print task result
+       task_result = await AWORLD_TASK_CLIENT.get_task_state(task_id=task_id)
+       print(task_result)
+
+   async def _batch_run_gaia_task(start_i: int, end_i: int) -> None:
+       """Run multiple Gaia tasks in parallel.
+       
+       Args:
+           start_i: Starting question ID
+           end_i: Ending question ID
+       """
+       tasks = [
+           _run_gaia_task(str(i))
+           for i in range(start_i, end_i + 1)
+       ]
+       await asyncio.gather(*tasks)
+
+   if __name__ == '__main__':
+       # Run batch processing for questions 1-5
+       asyncio.run(_batch_run_gaia_task(1, 5))
+   ```
+   c. user curl
+```shell
+curl http://localhost:9299/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer 0p3n-w3bu!" \
+  -d '{
+  "model": "gaia_agent",
+  "messages": [
+    {
+      "role": "user",
+      "content": [
+        {
+          "type": "text",
+          "text": "5"
+        }
+      ]
+    }
+  ]
+}'
+
+```
+
+
+## 🔑 Key Features
+
+- **Distributed Task Processing System**
+  - Multi-server load balancing
+  - Round-robin task distribution
+  - Asynchronous task processing
+
+- **Docker Containerization**
+  - Multi-instance deployment
+  - Environment variable configuration
+  - Auto-restart mechanism
+
+- **API Services**
+  - FastAPI framework support
+  - RESTful API design
+  - Asynchronous request handling
+
+- **Development Tools**
+  - Debug mode support
+  - Batch task processing
+  - Task state tracking
+
+- **Security Features**
+  - API key authentication
+  - Session management
+  - User authentication
+
+
+
+## 📦 Installation and Setup
+
+Get started with aworldserver in a few easy steps:
+
+1. **Ensure Python 3.11 is installed.**
+
+2. **Install the required dependencies:**
+
+   ```sh
+   pip install -r requirements-minimux.txt
+   ```
+
+3. **Start the aworld server:**
+
+   ```sh
+   sh ./start.sh
+   ```
+### Custom debug
+
+please run `debug_run.py`
+
+## 

AWorld-main/aworlddistributed/base.py

@@ -0,0 +1,72 @@
+import uuid
+from typing import Any
+from typing import List, Optional
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict
+from pydantic import Field
+
+
+class AworldTask(BaseModel):
+    task_id: str = Field(default=None, description="task id")
+    agent_id: str = Field(default=None, description="agent id")
+    agent_input: str = Field(default=None, description="agent input")
+    session_id: Optional[str] = Field(default=None, description="session id")
+    user_id: Optional[str] = Field(default=None, description="user id")
+    llm_provider: Optional[str] = Field(default=None, description="llm provider")
+    llm_model_name: Optional[str] = Field(default=None, description="llm model name")
+    llm_api_key: Optional[str] = Field(default=None, description="llm api key")
+    llm_base_url: Optional[str] = Field(default=None, description="llm base url")
+    llm_custom_input: Optional[str] = Field(default=None, description="custom_input")
+    task_system_prompt: Optional[str] = Field(default=None, description="task_system_prompt")
+    mcp_servers: Optional[list[str]] = Field(default=None, description="mcp_servers")
+    node_id: Optional[str] = Field(default=None, description="execute task node_id")
+    client_id: Optional[str] = Field(default=None, description="submit client ip")
+    status: Optional[str] = Field(default="INIT", description="submitted/running/execute_failed/execute_success")
+    history_messages: Optional[int] = Field(default=100, description="history_message")
+    max_steps: Optional[int] = Field(default=100, description="max_steps")
+    max_retries: Optional[int] = Field(default=5, description="max_retries use Exponential backoff with jitter")
+    ext_info: Optional[dict] = Field(default_factory=dict, description="custom")
+    created_at: Optional[datetime] = Field(default=None, description="created time")
+    updated_at: Optional[datetime] = Field(default=None, description="updated time")
+
+    def mark_running(self):
+        self.status = 'RUNNING'
+
+    def mark_failed(self):
+        self.status = 'FAILED'
+
+    def mark_success(self):
+        self.status = 'SUCCESS'
+
+class AworldTaskResult(BaseModel):
+    task: AworldTask = Field(default=None, description="task")
+    server_host: Optional[str] = Field(default=None, description="aworld server id")
+    data: Any = Field(default=None, description="result data")
+
+class AworldTaskForm(BaseModel):
+    batch_id: str = Field(default=str(uuid.uuid4()), description="batch_id")
+    task: Optional[AworldTask] = Field(default=None, description="task")
+    user_id: Optional[str] = Field(default=None, description="user id")
+    client_id: Optional[str] = Field(default=None, description="submit client ip")
+
+
+class OpenAIChatMessage(BaseModel):
+    role: str
+    content: str | List
+
+    model_config = ConfigDict(extra="allow")
+
+
+class OpenAIChatCompletionForm(BaseModel):
+    stream: bool = True
+    model: str
+    messages: List[OpenAIChatMessage]
+
+    model_config = ConfigDict(extra="allow")
+
+
+class FilterForm(BaseModel):
+    body: dict
+    user: Optional[dict] = None
+    model_config = ConfigDict(extra="allow")

AWorld-main/aworlddistributed/config.py

@@ -0,0 +1,30 @@
+import os
+import logging
+from pathlib import Path
+
+from aworld.utils.common import get_local_ip
+
+####################################
+# Load .env file
+####################################
+
+try:
+    from dotenv import load_dotenv, find_dotenv
+
+    load_dotenv(find_dotenv("./.env"))
+except ImportError:
+    print("dotenv not installed, skipping...")
+
+# Define log levels dictionary
+LOG_LEVELS = {
+    'DEBUG': logging.DEBUG,
+    'INFO': logging.INFO,
+    'WARNING': logging.WARNING,
+    'ERROR': logging.ERROR,
+    'CRITICAL': logging.CRITICAL
+}
+ROOT_DIR = Path(__file__).parent  # the path containing this file
+AGENTS_DIR = os.getenv("AGENTS_DIR", "./aworldspace/agents")
+ROOT_LOG = os.path.join(os.getenv("LOG_DIR_PATH", "logs") , get_local_ip())
+WORKSPACE_TYPE = os.environ.get("WORKSPACE_TYPE", "local")
+WORKSPACE_PATH = os.environ.get("WORKSPACE_PATH", "./data/workspaces")

AWorld-main/aworlddistributed/debug_run.py

@@ -0,0 +1,7 @@
+import uvicorn
+from dotenv import load_dotenv
+
+if __name__ == "__main__":
+    load_dotenv()
+    import main
+    uvicorn.run(main.app, host="0.0.0.0", port=9999)

AWorld-main/aworlddistributed/docker-compose.yaml

@@ -0,0 +1,22 @@
+services:
+  aworldserver-1:
+      image: aworldserver:main
+      volumes:
+        - ./.env:/app/.env
+      ports:
+        - "9299:9099"
+      restart: always
+  aworldserver-2:
+    image: aworldserver:main
+    volumes:
+      - ./.env:/app/.env
+    ports:
+      - "9399:9099"
+    restart: always
+  aworldserver-3:
+    image: aworldserver:main
+    volumes:
+      - ./.env:/app/.env
+    ports:
+      - "9499:9099"
+    restart: always

AWorld-main/aworlddistributed/main.py

@@ -0,0 +1,143 @@
+import logging
+import os
+import time
+from contextlib import asynccontextmanager
+from logging.handlers import TimedRotatingFileHandler
+import uvicorn
+
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+
+from aworld.cmd.web.routers import workspaces
+from aworldspace.routes import tasks
+from aworldspace.utils.job import generate_openai_chat_completion
+from aworldspace.utils.loader import load_modules_from_directory, PIPELINE_MODULES, PIPELINES
+from base import OpenAIChatCompletionForm
+from config import AGENTS_DIR, LOG_LEVELS, ROOT_LOG
+
+if not os.path.exists(AGENTS_DIR):
+    os.makedirs(AGENTS_DIR)
+
+# Add GLOBAL_LOG_LEVEL for Pipeplines
+log_level = os.getenv("GLOBAL_LOG_LEVEL", "INFO").upper()
+logging.basicConfig(level=LOG_LEVELS[log_level])
+def setup_logging():
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+    log_dir = ROOT_LOG
+    if not os.path.exists(log_dir):
+        os.makedirs(log_dir)
+    log_path = os.path.join(log_dir, "aworldserver.log")
+    file_handler = TimedRotatingFileHandler(log_path, when='H', interval=1, backupCount=24)
+    file_handler.setLevel(logging.INFO)
+
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    file_handler.setFormatter(formatter)
+
+    error_log_path = os.path.join(log_dir, "aworldserver_error.log")
+    error_file_handler = TimedRotatingFileHandler(error_log_path, when='D', interval=1, backupCount=24)
+    error_file_handler.setLevel(logging.WARNING)
+    error_file_handler.setFormatter(formatter)
+
+    logger.addHandler(file_handler)
+    logger.addHandler(error_file_handler)
+setup_logging()
+
+
+async def on_startup():
+    await load_modules_from_directory(AGENTS_DIR)
+    await tasks.task_manager.start_task_executor()
+
+    for module in PIPELINE_MODULES.values():
+        if hasattr(module, "on_startup"):
+            await module.on_startup()
+
+
+async def on_shutdown():
+    for module in PIPELINE_MODULES.values():
+        if hasattr(module, "on_shutdown"):
+            await module.on_shutdown()
+
+
+async def reload():
+    await on_shutdown()
+    # Clear existing pipelines
+    PIPELINES.clear()
+    PIPELINE_MODULES.clear()
+    # Load pipelines afresh
+    await on_startup()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await on_startup()
+    yield
+    await on_shutdown()
+
+
+app = FastAPI(docs_url="/docs", redoc_url=None, lifespan=lifespan)
+
+
+origins = ["*"]
+
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+app.include_router(tasks.router, prefix="/api/v1/tasks", tags=["tasks"])
+app.include_router(workspaces.router, prefix="/api/v1/workspaces", tags=["workspace"])
+
+
+@app.middleware("http")
+async def check_url(request: Request, call_next):
+    start_time = int(time.time())
+    response = await call_next(request)
+    process_time = int(time.time()) - start_time
+    response.headers["X-Process-Time"] = str(process_time)
+
+    return response
+
+@app.get("/v1")
+@app.get("/")
+async def get_status():
+    return {"status": True}
+
+
+@app.post("/v1/chat/completions")
+@app.post("/chat/completions")
+async def chat_completion(form_data: OpenAIChatCompletionForm, request: Request
+                          ):
+    # Extract headers into a dict
+    headers = request.headers
+    if headers.get("x-aworld-session-id"):
+        metadata = {
+            "user_id": headers.get("x-aworld-user-id"),
+            "chat_id": headers.get("x-aworld-session-id"),
+            "message_id": headers.get("x-aworld-message-id")
+        }
+
+        # Add metadata to form_data
+        form_data.metadata = metadata
+
+    return await generate_openai_chat_completion(form_data)
+
+@app.get("/health")
+async def healthcheck():
+    return {
+        "status": True
+    }
+
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "aworlddistributed.main:app",
+        host="0.0.0.0",
+        port=8088,
+        reload=True,
+    )

AWorld-main/aworlddistributed/requirements.txt

@@ -0,0 +1,44 @@
+--index-url https://mirrors.aliyun.com/pypi/simple/
+
+fastapi==0.111.0
+uvicorn[standard]==0.23.1
+pydantic==2.9.2
+python-multipart==0.0.9
+python-socketio
+grpcio
+
+passlib==1.7.4
+passlib[bcrypt]
+PyJWT[crypto]
+
+requests==2.32.2
+aiohttp==3.9.5
+httpx
+
+datasets==3.3.2
+executing
+flask
+openpyxl
+selenium==4.32.0
+fitz==0.0.1.dev2
+tabulate==0.9.0
+frontend
+tools
+PyPDF2
+html2text
+xmltodict
+docx2markdown
+python-pptx
+browser_use
+
+oss2
+prometheus_client~=0.21.1
+opentelemetry-sdk~=1.32.1
+opentelemetry-api~=1.32.1
+opentelemetry-exporter-otlp~=1.32.1
+opentelemetry-instrumentation-system-metrics~=0.53b1
+e2b_code_interpreter
+
+sqlalchemy~=2.0.40
+psycopg2-binary==2.9.9
+bcrypt==4.3.0

AWorld-main/aworlddistributed/start.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+PORT="${PORT:-9099}"
+HOST="${HOST:-0.0.0.0}"
+# Default value for PIPELINES_DIR
+PIPELINES_DIR=${PIPELINES_DIR:-./aworldspace/agents}
+
+UVICORN_LOOP="${UVICORN_LOOP:-auto}"
+
+# OSS mount configuration - read from environment variables
+if [ -n "$OSS_BUCKET" ] && [ -n "$OSS_AK_ID" ] && [ -n "$OSS_AK_SECRET" ]; then
+    echo "Configuring OSS mount..."
+
+    # Create OSS credentials file
+    echo "${OSS_BUCKET}:${OSS_AK_ID}:${OSS_AK_SECRET}" >> /etc/passwd-ossfs
+    chmod 640 /etc/passwd-ossfs
+
+    # Create mount point directories if they don't exist
+    mkdir -p /app/logs
+    mkdir -p /app/trace_data
+    mkdir -p /app/aworldspace/datasets
+
+    # Mount OSS directories
+    echo "Mounting OSS directories..."
+    if [ -n "$OSS_REGION_URL" ] && [ -n "$OSS_BUCKET_URL" ]; then
+        # Use custom region and URL
+        ossfs ${OSS_BUCKET}:/aworld/logs /app/logs -odirect_read -ononempty -oregion=${OSS_REGION_URL} -ourl=${OSS_BUCKET_URL} &
+        ossfs ${OSS_BUCKET}:/aworld/trace_data /app/trace_data -odirect_read -ononempty -oregion=${OSS_REGION_URL} -ourl=${OSS_BUCKET_URL} &
+        ossfs ${OSS_BUCKET}:/aworld/datasets /app/aworldspace/datasets -odirect_read -ononempty -oregion=${OSS_REGION_URL} -ourl=${OSS_BUCKET_URL} &
+    else
+        # Use default configuration
+        ossfs ${OSS_BUCKET}:/aworld/logs /app/logs -odirect_read -ononempty &
+        ossfs ${OSS_BUCKET}:/aworld/trace_data /app/trace_data -odirect_read -ononempty &
+        ossfs ${OSS_BUCKET}:/aworld/datasets /app/aworldspace/datasets -odirect_read -ononempty &
+    fi
+
+    # Wait for mount to complete
+    sleep 2
+    echo "OSS mount configuration completed"
+else
+    echo "OSS configuration incomplete, skipping OSS mount"
+fi
+
+
+uvicorn main:app --host "$HOST" --port "$PORT" --forwarded-allow-ips '*' --loop "$UVICORN_LOOP"
+