[用户] → 全局负载均衡器 (基于地理IP)
            ↓
        +------------------+          +------------------+
        | 柔佛Agent网关     |          | 新加坡Agent网关   |
        | (处理马来/印尼用户)|          | (处理其他东南亚用户)|
        +------------------+          +------------------+
            |                                |
        +-----------+                   +-----------+
        | 规划器节点 |(柔佛)             | 规划器节点 |(新加坡)
        | 记忆:本地 |                   | 记忆:本地 |
        +-----------+                   +-----------+
            |                                |
        +-----------+                   +-----------+
        | 工具执行器|(柔佛)             | 工具执行器|(新加坡)
        | 包括本地API|                  | 包括本地API|
        +-----------+                   +-----------+
            |                                |
        +------------------------------------------+
        |          跨区域事件总线 (Kafka/Pulsar)      |
        +------------------------------------------+
            |                                |
        +-----------+                   +-----------+
        | 全局记忆库 |(合规分区存储)        |           |
        +-----------+                   +-----------+

def route_agent_request(user_location, request):
    # 1. 根据用户位置选择最近的数据中心
    user_region = get_nearest_dc(user_location)  # 返回 'johor'
    
    # 2. 在选择的区域创建Agent实例
    agent = Agent(region=user_region)
    
    # 3. 规划器在本地执行，工具调用检查归属
    plan = agent.planner.plan(request)
    for step in plan:
        if step.tool.region_required and step.tool.region != user_region:
            # 跨区域工具调用，通过事件总线转发
            result = async_call_tool_remote(step.tool, region=step.tool.region)
        else:
            result = agent.tool_executor.run(step.tool, local_mode=True)
        
    # 4. 记忆写入：本地短期记忆写入区域存储，长期记忆写入全局存储（脱敏后）
    agent.memory.store_local(context)
    agent.memory.store_global(anonymize(context))

# region_agent.py
from fastapi import FastAPI, Request
import redis
import json
import asyncio
import uuid

app = FastAPI()
redis_client = redis.Redis(host='localhost', port=6379, decode_responses=True)

# 模拟两个区域
REGIONS = ['johor', 'singapore']

class MockPlanner:
    def plan(self, user_query):
        # 模拟一个两步计划
        return [
            {'tool': 'search', 'args': {'query': user_query}},
            {'tool': 'summarize', 'args': {'max_length': 100}}
        ]

class MockToolExecutor:
    async def run(self, tool_name, args):
        await asyncio.sleep(0.05)  # 模拟延迟
        return f"Result from {tool_name}: {args}"

# 每个区域的Agent实例
class RegionalAgent:
    def __init__(self, region):
        self.region = region
        self.planner = MockPlanner()
        self.executor = MockToolExecutor()
        self.session_id = str(uuid.uuid4())
        # 区域专用记忆key
        self.memory_key = f"agent:{self.region}:{self.session_id}"
    
    async def execute(self, user_query):
        # 保存初始状态
        redis_client.set(self.memory_key, json.dumps({'step': 0, 'query': user_query}))
        plan = self.planner.plan(user_query)
        results = []
        for step_num, step in enumerate(plan):
            result = await self.executor.run(step['tool'], step['args'])
            results.append(result)
            # 更新状态
            redis_client.set(self.memory_key, json.dumps({'step': step_num+1, 'results': results}))
        return results

@app.post("/agent")
async def handle_agent(request: Request):
    body = await request.json()
    user_location = body.get('location', 'default')
    query = body.get('query', '')
    
    # 路由逻辑
    if user_location in ['malaysia', 'indonesia', 'thailand']:
        region = 'johor'
    else:
        region = 'singapore'
    
    agent = RegionalAgent(region)
    results = await agent.execute(query)
    return {
        'region': region,
        'session_id': agent.session_id,
        'results': results
    }

# 运行: uvicorn region_agent:app --reload --port 8000 （柔佛用8000，新加坡用8001模拟）