AgentScope Multi-Agent Platform

AgentScope provides an out-of-the-box Agent Service based on FastAPI, designed to transform agents into multi-tenant, multi-session applications. It includes a pre-built Web UI (found in examples/web_ui) and supports the following core capabilities:

• Service: Multi-tenancy, multi-session isolation, FastAPI backend, and pre-built Web UI.
• Agent Teams: Leader–Worker orchestration, built-in team tools, and task planning.
• Message Channels: Integration with IM platforms like Lark (Feishu), Discord, and custom channels via message routing.
• RAG Service: Blob storage, Index Workers, and multi-tenant retrieval.
• MCP & Skill Hub: Browsing Hubs (e.g., GitHub MCP Registry, ClawHub), installing skills to your library, and adding them to workspaces.
• Resource Sharing: Resource management for groups and organizations, including shared models, MCP services, skills, and workspaces.
• Persistence: SQL & NoSQL persistence for agent states and sessions.
• Scheduling: Scheduled tasks, agent wake-ups, and background task offloading.

AgentScope 2.0 provides several core abstractions to build agentic applications:

The mode parameter determines how the middleware interacts with the agent and what the LLM sees.

static_control

The middleware operates automatically without the agent's explicit involvement.

1. Pre-reply: Queries mem0 with the latest user message.
2. At ReplyStartEvent: Appends an AssistantMsg(name="memory", ...) to the agent's context immediately after the user message. This makes the retrieved memory part of the context for the reasoning loop.
3. Post-reply: Writes the new (user, assistant) exchange back to mem0.

agent_control

The middleware provides tools for the agent to manage its own memory. You must explicitly add these tools to the agent's toolkit.

• Tools provided: search_memory(keywords, limit) and add_memory(thinking, content).
• The agent is given a system prompt hint that these tools exist, but no automatic retrieval or write-back occurs.

both (Default)

Both patterns are active. Memories are automatically retrieved and appended to the context, AND the agent has access to the memory tools for explicit on-demand search and saving.

# Example of agent_control mode
from agentscope.agent import Agent
from agentscope.tool import Toolkit

mw = Mem0Middleware(user_id="alice", mode="agent_control")
agent = Agent(
    ...,
    toolkit=Toolkit(tools=await mw.list_tools()),
    middlewares=[mw],
)

The AppleContainerWorkspace follows an asynchronous lifecycle managed via initialize() or the async with context manager.

• Initialization: When entering the async with block (or calling initialize()), the container is created, the base image is pulled (if not cached), the gateway venv is bootstrapped (via apt-get, uv, and pip), and the MCP gateway starts.
• Execution: Once initialized, you can access the backend to execute commands.
• Cleanup: When exiting the async with block (or calling close()), the container is stopped and removed. Note: Filesystem state is not persisted.
• Idempotency: A second initialize() call on the same container name is a no-op if the container is already running.

import asyncio
from agentscope.workspace import AppleContainerWorkspace

async def main():
    async with AppleContainerWorkspace() as ws:
        # Container is created, bootstrapped, gateway is running.
        backend = ws.get_backend()
        result = await backend.exec_shell(["echo", "hello"])
        print(result.stdout)

    # Container is stopped and removed.

asyncio.run(main())

When you provide chat_model and embedding_model to build_mem0_config, AgentScope acts as the backend for mem0 through the following mechanism:

1. Provider Registration: It registers AgentScopeLLM and AgentScopeEmbedding in mem0's factory under the provider name "agentscope".
2. Config Substitution: It substitutes standard mem0 LlmConfig and EmbedderConfig with specialized subclasses that allow the "agentscope" provider name.
3. Adapter Routing: It builds an AsyncMemory instance where .llm and .embedding_model calls are routed through AgentScope adapters.
4. Async Bridging: It bridges mem0's synchronous API to AgentScope's asynchronous models using a persistent background event loop, ensuring connection pools (like those in Ollama's AsyncClient) are maintained across calls.

Note on Dimensions: Ensure your embedding model's dimensions match the vector store's requirements. For example, mem0's default Qdrant expects 1536 dimensions (matching DashScope's text-embedding-v2).

AgentScope 2.0 provides a suite of modules to build production-ready agents: