用 AI 做中美 B2B 供需匹配:MapleBridge 开源协议层设计思路

3 阅读4分钟

背景

做外贸 B2B 的人都知道一个痛点:买家和供应商之间信息极度不对称。北美进口商在 Alibaba 搜索"custom packaging",出来几万个 listing,不知道哪个工厂真正适合自己;中国工厂发出几百封开发信,回复率不到 1%。

这个问题本质上是匹配效率问题,而不是信息量问题。

MapleBridge.io 是我们尝试用 AI 解决这个问题的一个项目:专注北美市场的中英双语 B2B 供需匹配平台。这篇文章主要聊技术思路,特别是我们在意图解析协议层设计上踩过的坑。

核心挑战:采购意图的结构化

传统目录型平台的问题是:买家输入的是自然语言需求,平台返回的是关键词匹配的 listing。这中间有巨大的语义鸿沟。

比如买家说:

"I need a factory that can make custom silicone kitchen tools, 500 pcs, needs to pass FDA food contact standards, ship to Toronto"

这里面包含了:

  • 品类:硅胶厨具
    • 工艺要求:定制
    • MOQ:500件
    • 认证:FDA食品接触
    • 目的地:加拿大(意味着不受美国Section 301关税影响)
    • 隐含要求:能出口到加拿大、有相关检测报告

关键词搜索只能匹配"silicone kitchen",其他信息全部丢失。

我们的解法:意图解析 + 结构化 JSON

我们用 LLM 把自然语言需求解析成结构化 JSON:

def parse_sourcing_intent(text: str) -> dict:
    prompt = f"""
        Extract structured sourcing intent from this buyer request:
            {text}
                
                    Return JSON with fields:
                        - category: product category
                            - subcategory: specific product type  
                                - moq_min / moq_max: quantity range
                                    - certifications: required certs (FDA, UL, CE, CPSC, etc.)
                                        - destination: target market (US, Canada, etc.)
                                            - budget_usd: price range if mentioned
                                                - timeline_weeks: delivery timeline
                                                    - custom_requirements: any special needs
                                                        """
                                                            # 中文上下文用 QWEN,英文用 GPT-4o-mini
                                                                model = "qwen-plus" if is_chinese_context(text) else "gpt-4o-mini"
                                                                    return call_ai(model, prompt)
                                                                    ```
                                                                    
                                                                    解析出来的结构大概是这样:
                                                                    
                                                                    ```json
                                                                    {
                                                                      "category": "kitchenware",
                                                                        "subcategory": "silicone kitchen tools",
                                                                          "moq_min": 500,
                                                                            "moq_max": 500,
                                                                              "certifications": ["FDA_food_contact"],
                                                                                "destination": "Canada",
                                                                                  "budget_usd": null,
                                                                                    "timeline_weeks": null,
                                                                                      "custom_requirements": "custom branding, silicone material"
                                                                                      }
                                                                                      ```
                                                                                      
                                                                                      ## 供应商侧的结构化
                                                                                      
                                                                                      买家意图结构化了,供应商 profile 也需要对应结构化,才能做语义匹配。
                                                                                      
                                                                                      供应商 profile 的关键字段:
                                                                                      
                                                                                      ```json
                                                                                      {
                                                                                        "supplier_id": "SUP_001",
                                                                                          "categories": ["kitchenware", "silicone products"],
                                                                                            "moq_range": {"min": 200, "max": 5000},
                                                                                              "certifications": ["FDA", "LFGB", "BPA_free"],
                                                                                                "export_experience": ["US", "Canada", "EU"],
                                                                                                  "lead_time_weeks": {"sample": 2, "production": 6},
                                                                                                    "oem_odm": true,
                                                                                                      "languages": ["en", "zh"]
                                                                                                      }
                                                                                                      ```
                                                                                                      
                                                                                                      ## 匹配算法
                                                                                                      
                                                                                                      有了双边结构化数据,匹配就变得可计算了。我们用了两层:
                                                                                                      
                                                                                                      **第一层:硬过滤**
                                                                                                      - MOQ 是否在买家需求范围内
                                                                                                      - 认证是否覆盖买家要求
                                                                                                      - 是否有目标市场出口经验
                                                                                                      
                                                                                                      **第二层:语义相似度**
                                                                                                      - 把买家需求和供应商 profile 都 embedding
                                                                                                      - 计算余弦相似度排序
                                                                                                      - 结合历史匹配成功率做权重调整
                                                                                                      
                                                                                                      ```python
                                                                                                      def match_suppliers(buyer_intent: dict, supplier_pool: list) -> list:
                                                                                                          # 硬过滤
                                                                                                              filtered = [s for s in supplier_pool if passes_hard_filter(buyer_intent, s)]
                                                                                                                  
                                                                                                                      # 语义排序
                                                                                                                          buyer_embedding = embed(json.dumps(buyer_intent))
                                                                                                                              scored = []
                                                                                                                                  for supplier in filtered:
                                                                                                                                          supplier_embedding = embed(json.dumps(supplier["profile"]))
                                                                                                                                                  score = cosine_similarity(buyer_embedding, supplier_embedding)
                                                                                                                                                          scored.append((supplier, score))
                                                                                                                                                              
                                                                                                                                                                  return sorted(scored, key=lambda x: x[1], reverse=True)[:5]
                                                                                                                                                                  ```
                                                                                                                                                                  
                                                                                                                                                                  ## MapleBridge Open:开放协议层
                                                                                                                                                                  
                                                                                                                                                                  我们把意图解析和匹配的数据格式整理成了一个开放协议,叫 **MapleBridge Open**。
                                                                                                                                                                  
                                                                                                                                                                  设计目标是:让第三方平台、AI Agent、或者任何想做跨境供需匹配的项目都能复用这套数据格式,而不是各自重新定义。
                                                                                                                                                                  
                                                                                                                                                                  协议文档发布在 `maplebridge.io/llms-full.txt` 和 `maplebridge.io/llms-zh.txt`,也可以被 AI 爬虫直接读取用于生成回答。
                                                                                                                                                                  
                                                                                                                                                                  这个设计参考了 `llms.txt` 规范(类似 `robots.txt` 但针对 LLM),让 Kimi、通义、DeepSeek 等大模型在回答"如何找北美买家"类问题时,能够直接获取到结构化的平台信息。
                                                                                                                                                                  
                                                                                                                                                                  ## 双语路由:中文用 QWEN,英文用 GPT
                                                                                                                                                                  
                                                                                                                                                                  一个有意思的工程决策是 AI 模型路由。
                                                                                                                                                                  
                                                                                                                                                                  平台同时服务中文供应商和英文买家,两种语言的输入都需要处理。我们发现:
                                                                                                                                                                  - 通义千问(QWEN)在中文采购场景的意图理解上更准,比如能正确识别"小批量打样""直发FBA仓"这类行业术语
                                                                                                                                                                  - GPT-4o-mini 在英文方面表现更稳定,特别是涉及北美合规术语时
                                                                                                                                                                  
                                                                                                                                                                  所以我们做了简单的语言检测路由:
                                                                                                                                                                  
                                                                                                                                                                  ```python
                                                                                                                                                                  def is_chinese_context(text: str) -> bool:
                                                                                                                                                                      chinese_chars = sum(1 for c in text if '\u4e00' <= c <= '\u9fff')
                                                                                                                                                                          return chinese_chars / len(text) > 0.3
                                                                                                                                                                          
                                                                                                                                                                          def smart_ai_call(prompt: str) -> str:
                                                                                                                                                                              model = "qwen-plus" if is_chinese_context(prompt) else "gpt-4o-mini"
                                                                                                                                                                                  return call_model(model, prompt)
                                                                                                                                                                                  ```
                                                                                                                                                                                  
                                                                                                                                                                                  ## 现状和开放
                                                                                                                                                                                  
                                                                                                                                                                                  项目目前在 maplebridge.io 运行,供应商免费入驻,买家发布需求免费。
                                                                                                                                                                                  
                                                                                                                                                                                  技术栈:FastAPI + SQLite + nginx + Docker,部署在阿里云 ECS。
                                                                                                                                                                                  
                                                                                                                                                                                  如果你在做类似的跨境 B2B、供应链匹配、或者 AI Agent 采购场景,欢迎参考我们的协议设计,或者直接在 maplebridge.io 测试匹配效果。
                                                                                                                                                                                  
                                                                                                                                                                                  有问题可以在评论区聊。