product_certification_advisor

Instructions

Implementation Reference

• src/mcp_emc_regulations/tools/advisor.py:138-244 (handler)

  Handler function for product_certification_advisor tool. Takes radios, markets, and optional form_factor arguments. Looks up certification requirements from a JSON matrix per market, computes timelines, and generates a certification roadmap with test overlap efficiencies.

  def _certification_advisor(arguments: dict[str, Any]) -> list[TextContent]:
      radios = arguments["radios"]
      markets = arguments["markets"]
      form_factor = arguments.get("form_factor", "module")
  
      result = "Product Certification Roadmap\n" + "=" * 60 + "\n\n"
      result += f"Radios: {', '.join(radios)}\n"
      result += f"Markets: {', '.join(m.upper() for m in markets)}\n"
      result += f"Form factor: {form_factor}\n\n"
  
      # Determine product type for matrix lookup
      radio_lower = [r.lower() for r in radios]
      has_wifi = any("wifi" in r or "802.11" in r for r in radio_lower)
      has_ble = any("ble" in r or "bluetooth" in r for r in radio_lower)
      has_cellular = any(t in r for r in radio_lower for t in ("lte", "5g", "nr", "cellular", "cat_m", "nb_iot"))
      has_lora = any("lora" in r for r in radio_lower)
      has_uwb = any("uwb" in r for r in radio_lower)
  
      if has_cellular:
          product_type = "cellular_module"
      elif has_wifi and has_ble:
          product_type = "wifi_ble_combo"
      elif has_wifi:
          product_type = "wifi_module"
      elif has_ble:
          product_type = "ble_module"
      elif has_lora:
          product_type = "lora_module"
      elif has_uwb:
          product_type = "uwb_module"
      else:
          product_type = "iot_gateway"
  
      if form_factor == "automotive_ecu":
          product_type = "automotive_ecu"
  
      matrix = CERT_MATRIX.get("matrix", CERT_MATRIX.get("product_types", {}))
      product_data = matrix.get(product_type, {})
  
      market_labels = {
          "us": "United States", "ca": "Canada", "eu": "European Union",
          "jp": "Japan", "kr": "Korea", "cn": "China",
          "au": "Australia/NZ", "in": "India", "br": "Brazil",
      }
  
      total_weeks = 0
      all_certs = []
  
      for mkt in markets:
          mkt_info = product_data.get(mkt, {})
          if not mkt_info:
              result += f"## {market_labels.get(mkt, mkt.upper())}\n"
              result += "  Data not available for this market/product combination.\n\n"
              continue
  
          result += f"## {market_labels.get(mkt, mkt.upper())}\n"
  
          certs = mkt_info.get("certifications", [])
          if certs:
              result += "  Required certifications:\n"
              for cert in certs:
                  result += f"    - {cert}\n"
                  all_certs.append(f"{mkt.upper()}: {cert}")
  
          if mkt_info.get("modular_approval") is not None:
              ma = mkt_info["modular_approval"]
              if isinstance(ma, bool):
                  result += f"  Modular approval: {'Available' if ma else 'Not available'}\n"
              else:
                  result += f"  Modular approval: {ma}\n"
  
          if mkt_info.get("sar_required"):
              result += f"  SAR: {mkt_info['sar_required']}\n"
  
          timeline = mkt_info.get("typical_timeline_weeks", "")
          if timeline:
              result += f"  Timeline: ~{timeline} weeks\n"
              try:
                  # Parse range like "4-6" or single number
                  parts = str(timeline).split("-")
                  total_weeks = max(total_weeks, int(parts[-1]))
              except (ValueError, IndexError):
                  pass
  
          if mkt_info.get("notes"):
              result += f"  Notes: {mkt_info['notes']}\n"
  
          result += "\n"
  
      # Summary
      result += "## Summary\n"
      result += f"  Total unique certifications: {len(all_certs)}\n"
      if total_weeks:
          result += f"  Estimated parallel timeline: ~{total_weeks} weeks (longest single market)\n"
  
      # Test overlaps
      result += "\n## Test Overlaps & Efficiencies:\n"
      if "us" in markets and "ca" in markets:
          result += "  - US/Canada: FCC and ISED testing can often share RF test data (MRA)\n"
      if "eu" in markets:
          result += "  - EU CE mark covers all 27 member states + EEA\n"
      if has_wifi and has_ble:
          result += "  - WiFi + BLE share 2.4 GHz testing (single test setup for co-located radios)\n"
      if form_factor == "module":
          result += "  - Module certification enables faster end-product approval in most markets\n"
  
      return [TextContent(type="text", text=result)]

• src/mcp_emc_regulations/tools/advisor.py:22-49 (schema)

  Schema/registration of the product_certification_advisor tool. Defines the tool name, description, and input schema accepting radios (array of strings), markets (array of strings), and optional form_factor (enum: module, end_product, automotive_ecu).

  Tool(
      name="product_certification_advisor",
      description=(
          "Get a complete certification roadmap for a multi-radio product across target markets. "
          "Identifies required certifications, test overlaps, modular approval options, "
          "and estimated timelines. The primary advisor tool."
      ),
      inputSchema={
          "type": "object",
          "properties": {
              "radios": {
                  "type": "array",
                  "items": {"type": "string"},
                  "description": "List of radio technologies (e.g., ['wifi_6e', 'ble_5.3', 'lte_cat_m1'])",
              },
              "markets": {
                  "type": "array",
                  "items": {"type": "string"},
                  "description": "Target markets (e.g., ['us', 'ca', 'eu', 'jp'])",
              },
              "form_factor": {
                  "type": "string",
                  "enum": ["module", "end_product", "automotive_ecu"],
                  "description": "Product form factor",
              },
          },
          "required": ["radios", "markets"],
      },

• src/mcp_emc_regulations/tools/advisor.py:124-126 (registration)

  Dispatch routing: when call_tool receives name 'product_certification_advisor', it delegates to the _certification_advisor handler method.

  async def call_tool(self, name: str, arguments: dict[str, Any]) -> list[TextContent]:
      if name == "product_certification_advisor":
          return self._certification_advisor(arguments)

• src/mcp_emc_regulations/registry.py:41-53 (registration)

  Auto-discovery in ToolRegistry: iterates all modules in the tools package, finds ToolModule subclasses (like AdvisorTools), and instantiates them. This is how the product_certification_advisor tool gets registered with the server.

  def _discover(self) -> None:
      """Import every module in the ``tools`` package and instantiate ToolModules."""
      for info in pkgutil.iter_modules(_tools_pkg.__path__, _tools_pkg.__name__ + "."):
          module = importlib.import_module(info.name)
          for attr_name in dir(module):
              attr = getattr(module, attr_name)
              if (
                  isinstance(attr, type)
                  and issubclass(attr, ToolModule)
                  and attr is not ToolModule
              ):
                  self._modules.append(attr())

• src/mcp_emc_regulations/tools/advisor.py:11-15 (helper)

  Data loading for certification_advisor: loads certification_matrix.json (used by the handler to look up per-market certification requirements, SAR info, modular approval, and timelines).

  CERT_MATRIX = load_json("certification_matrix.json")
  XREF = load_json("standard_cross_references.json")
  WIFI = load_json("wifi_standards.json")
  BLUETOOTH = load_json("bluetooth_standards.json")
  SHORT_RANGE = load_json("short_range_wireless.json")