Commonlands Optics: M12 Lens and C-Mount Lens Finder + Field-of-View Calculator

com.commonlandsPublished by commonlands.comOfficial publisherv0.4.2Updated Oct 24, 2026

M12 lens and C-mount lens finder with image-sensor matching and field-of-view calculator.

VerifiedStreamable HTTPWeb executableDeveloper ToolsData & AnalyticsBusiness & Commerce

Overview

AI-generated overview

Commonlands optics server for finding M12 and C-mount lenses, matching them to image sensors, and calculating field of view.

What you can do
  • Calculate field of view for a lens/sensor pair, with HFOV, VFOV, DFOV, coverage and distortion status
  • Match and rank lenses to a sensor, target field of view, working distance or mount, and compare or recommend lenses for an application
  • Search the lens catalog by SKU, mount, lens type or application text, and read sensor specs and distortion profiles
  • Read live Shopify product data such as SKUs, prices, availability and product URLs, and search or look up catalog entries
  • Create, read and update Shopify-owned carts, and prepare read-only purchase handoffs and route options
  • Submit a buyer-confirmed request for quote or engineering question to the vendor
When to use it
Useful when choosing optics for a camera build: picking an M12 or C-mount lens for a specific sensor, checking whether a lens covers a sensor, or quoting live price and availability before handing a buyer to a cart.
Requirements
Remote streamable HTTP endpoint; no authentication or API keys are needed from the client. Some clients need a local bridge such as mcp-remote via npx. The server's own backend connectors and secrets are configured on the vendor side.
Before you install
The endpoint is public and unauthenticated. Cart tools create and change Shopify carts, so only call them after a buyer confirms exact variant IDs and quantities; carts are owner-bound by a cart access token that must be kept. submit_rfq sends a message to the vendor's engineering inbox after a preview and explicit confirmation. Fixture catalog data is not final commerce truth; use the live product read for prices and availability. Do not send card or payment data.

Installation

In SourceWeft

  1. Open Commonlands Optics: M12 Lens and C-Mount Lens Finder + Field-of-View Calculator in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/com.commonlands%2Foptics-mcp/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "commonlands-optics-m12-lens-and-c-mount": {
      "type": "http",
      "url": "https://mcp.commonlands.com/mcp"
    }
  }
}

README

Commonlands MCP

Public MCP server for Commonlands precision optics. Use it to choose M12/C-mount lenses, calculate field of view, verify live Shopify product truth, and hand buyers to Shopify-owned carts safely.

Connect

Copy-paste agent instruction

text
Use Commonlands MCP at https://mcp.commonlands.com/mcp for lens selection. Start with tools/list. Catalog EFL, image circle, max FoV/FOV@image-circle, and distortion display fields are insufficient to compute FoV on a specific sensor; do not interpolate or estimate sensor FoV from those fields. Use calculate_field_of_view for one lens/sensor pair, match_lens_to_sensor for sensor/target-FoV selection, search_lens_catalog for broad catalog discovery, and get_lens_distortion_profile for distortion status. Preserve the returned method, distortion_model, coverage_ok, image_circle_mm, sensor_diagonal_mm, and rectilinear_comparison. Call read_shopify_products before stating live price, availability, Product/Variant GIDs, URL, SKU, media, metafields, inventory, or cart payload. Only call create_cart/update_cart after the buyer confirms exact live Variant GIDs and quantities. Checkout tools are not live unless they appear in tools/list. Never ask for card data or perform Shopify catalog/inventory/order/customer writes.

Agent workflow

  1. Call tools/list and trust the live list over docs.
  2. For sensor-specific lens finding, call match_lens_to_sensor first, then call calculate_field_of_view for final candidate lens/sensor FoV claims.
  3. Use search_lens_catalog only for broad SKU/title/mount/lens-type discovery. It does not replace per-sensor FoV calculation.
  4. Get per-object grounding with resources/read for commonlands://sensors/{part} or commonlands://lenses/{sku} when needed.
  5. Use get_lens_distortion_profile for distortion/model/status questions. Do not invent polynomial coefficients or claim measured correction when the response says source-display-only.
  6. Use prompts/list / prompts/get with select_lens_for_sensor_fov_working_distance when a client surfaces MCP prompts.
  7. Verify purchasable truth with read_shopify_products before quoting final SKU, URL, price, availability, Shopify IDs, or cart payloads.
  8. Create/update a Shopify cart only after explicit buyer confirmation of line items and quantities.
  9. Send the buyer to Shopify's returned cart/checkout URL. Do not claim Checkout MCP is live until checkout tools appear in tools/list.

FoV rule

Catalog EFL, image circle, max FoV/FOV@image-circle, and distortion display fields are insufficient to compute field of view on a specific sensor. Agents must not interpolate interior-sensor FoV or substitute their own calculations. Use calculate_field_of_view, then preserve returned hfov_deg, vfov_deg, dfov_deg, method, distortion_model, coverage_ok, image_circle_mm, sensor_diagonal_mm, rectilinear_comparison, and provenance/source metadata in the answer.

Truth hierarchy

  1. read_shopify_products = live Shopify product truth.
  2. calculate_field_of_view / match_lens_to_sensor = live FoV backend (AWS Lambda + DynamoDB lens catalog) when configured. Sensor inputs resolve through the live DynamoDB sensor catalog with fixture fallback. These are the routed public optics tools.
  3. Compatibility aliases (compute_fov, compute_fov_catalog, match_lenses_to_sensor) still dispatch where practical, but new clients should route through the intent-named tools above.
  4. Ranking tools (match_lens_to_sensor, recommend_lenses_for_application, compare_lenses) rank against live FoV-backend specs and field of view when the live backend is enabled, so they use real per-SKU specs (EFL, mount, image circle, FoV). They still exclude live Shopify stock/price/variant IDs; use read_shopify_products for purchasable truth. If the live backend is unconfigured they fall back to fixture scaffold.
  5. The remaining fixture catalog/product-page tools = useful engineering context, not final commerce truth. If the live backend is ever unconfigured, FoV tools fail closed and sensor lookups fall back to a small reference fixture.

If fixture data conflicts with read_shopify_products or the live FoV/sensor backends, use the live truth.

Data sources

  • Sensors (commonlands://sensors/{part} and the sensor used by calculate_field_of_view / match_lens_to_sensor): read from the Commonlands DynamoDB sensor table by part number when configured, with fixture fallback. Pixel pitch and pixel counts come straight from that table; active-area mm is derived as pixels x pitch.
  • Lenses (commonlands://lenses/{sku}, calculate_field_of_view, match_lens_to_sensor, search_lens_catalog): the FoV Lambda reads lens optical parameters from its DynamoDB lens table when configured. Catalog-wide matching covers the full lens table when backend scanning is enabled.
  • Distortion coefficients are computed server-side inside the Lambda and are never returned to clients. If the live backend only returns a display distortion string, MCP returns an honest distortion_model / distortion_status and does not claim measured polynomial correction.

Current live surface

With the three standard cart tools enabled, this version exposes 21 tools across catalog/search, FoV, Shopify read-only, cart, UCP catalog, RFQ, and purchase-handoff. Checkout tools, cancel_cart, and read_shopify_metaobjects remain excluded from that configuration. Always trust the live tools/list over any doc.

Key tools:

  • Public optics routing: calculate_field_of_view, match_lens_to_sensor, search_lens_catalog, get_lens_distortion_profile.
  • Catalog/context (in tools/list): search_catalog, lookup_catalog, get_product, get_product_page_details, compare_lenses, recommend_lenses_for_application.
  • Legacy hidden aliases (still dispatch for old clients, not listed in tools/list): compute_fov, compute_fov_catalog, match_lenses_to_sensor, search_lenses, get_lens_details.
  • Resources/prompts: commonlands://sensors/{part}, commonlands://lenses/{sku}, commonlands://catalog/sensors, commonlands://catalog/lenses, and prompt select_lens_for_sensor_fov_working_distance.
  • Live Shopify read-only truth: read_shopify_products, get_shopify_readonly_config_status.
  • Buyer-confirmed Shopify cart handoff: create_cart, get_cart, update_cart when visible in tools/list.
  • RFQ / question handoff: submit_rfq forwards a buyer quote request or question to the fixed Commonlands engineering inbox (SendGrid). The agent cannot choose the recipient; it sends an inquiry only (no order, payment, or Shopify write) and stays inert (routes to the contact page) until SENDGRID_API_KEY + RFQ_TO_EMAIL + RFQ_FROM_EMAIL are configured.
  • Diagnostics/readiness: get_catalog_snapshot_status, get_shopify_ucp_readiness, prepare_shopify_purchase_handoff, get_purchase_route_options.

Public-data scope (Shopify reads)

The endpoint is public and unauthenticated, so read_shopify_products returns only data that is already public on commonlands.com (enforced server-side in src/shopify-read-adapter.ts, see PUBLIC_DATA_POLICY):

  • Published active products only. Products must be ACTIVE and have a Shopify-provided Online Store URL on commonlands.com. An ACTIVE product with no publication is filtered out; the adapter never invents its URL.
  • No exact inventory. Variants carry a coarse availability signal (in_stock / low_stock / out_of_stock / untracked); raw counts and inventory item IDs are never returned.
  • Metafields are opt-in and allowlisted. includeMetafields defaults to false; when enabled, only the custom.* display fields rendered on public product pages are returned. App/private namespaces and non-allowlisted keys (including custom.docsend_page) are always dropped.
  • read_shopify_metaobjects was removed from the public surface (2026-07): Admin metaobject definitions can hold non-public store content. Calls return an actionable error pointing to read_shopify_products.
  • The requested Admin scopes were narrowed to the read scopes the surface actually needs (no metaobject, marketing, payment-terms, or shipping scopes).

Abuse controls (cart and endpoint)

Cart tools are deliberately reachable without authentication — the same trust model as Shopify's own public Storefront cart — but they are bounded:

  • Per-IP rate limits (Workers Rate Limiting API, wrangler.toml): 120 requests/min per IP across /mcp, and 10 cart mutations/min per IP for create_cart/update_cart. Exceeding either returns HTTP 429 with retry-after: 60.
  • Strict payloads: 1–25 line items per cart, quantity 1–999 per line, and item IDs must be live Shopify ProductVariant GIDs — fixture IDs, SKUs, and numeric IDs are rejected before any Shopify call.
  • Carts are Shopify-owned and expire. The Worker is a stateless proxy; cart state, TTL, and expiry (expiryAuthority: shopify_cart_ttl_expires_at) belong to Shopify, which prunes abandoned carts automatically. No cart, session, customer, or payment state is ever stored in the Worker.
  • No checkout surface: checkout/cancel tools are hidden; the server cannot take payment, create orders or customers, apply discounts, or write inventory, so an abusive caller cannot mutate anything durable.

Safety boundaries

  • Do not use fixture prices, availability, product URLs, SKU variants, or IDs as final commerce truth.
  • Do not create or update carts unless the buyer has confirmed live Variant GIDs and quantities.
  • Do not use Checkout MCP yet; checkout endpoints will be enabled later after validation and approval.
  • Do not ask for or transmit card numbers, CVV/CVC, payment tokens, passwords, or customer account credentials.
  • Do not perform Shopify product, variant, collection, tag, metafield, inventory, order, customer, discount, RFQ, Acumatica, or database writes.
  • Do not expose gated datasheet URLs or backend secrets.
  • For live FoV, call Commonlands MCP only. Do not call the AWS Lambda/API Gateway backend directly.

Good prompts

  • Find M12 lenses for IMX477 around 50° horizontal FoV. Use match_lens_to_sensor, calculate_field_of_view, then verify the final purchasable SKU with read_shopify_products.
  • Compare CIL078 and CIL250 on IMX477. Preserve rectilinear_comparison and label fixture-backed context separately from live Shopify truth.
  • Find the live Shopify Product and Variant GID for CIL250. Return URL, SKU, price, inventory signal, and cart path, but do not create a cart.
  • Create a Shopify cart for two units of this live Variant GID: <gid>. The buyer has confirmed quantity 2.
  • List Commonlands MCP tools and classify each as fixture context, live FoV, live Shopify read-only, or Shopify cart.

Observability

Version 0.4.2 also withholds fixture prices, availability, and product URLs from legacy tool responses (including nested UCP variants and purchase routes) and catalog resources. Use read_shopify_products for current commerce values; fixture responses provide a commerceLookup instruction instead of a stale quote. When a horizontal FoV target is supplied, ranking prioritizes full sensor coverage, then absolute target error, then heuristic score and SKU. Capped scores no longer cause an exact target match to lose to an alphabetically earlier lens.

The Worker can write privacy-safe request/tool telemetry when a Cloudflare Analytics Engine binding named MCP_ANALYTICS is configured. Telemetry records only method, path, MCP method, tool name, status, client label, environment/version, HTTP status, and duration. It does not record request arguments, Shopify payloads, customer data, product IDs, cart IDs, secrets, or response bodies.

Example binding:

toml
[[analytics_engine_datasets]]binding = "MCP_ANALYTICS"dataset = "commonlands_mcp_events"

After deploy, verify that telemetry is live:

bash
curl https://mcp.commonlands.com/healthzcurl -X POST https://mcp.commonlands.com/mcp \  -H 'content-type: application/json' \  -H 'accept: application/json, text/event-stream' \  -H 'mcp-client-name: telemetry-smoke' \  -d '{"jsonrpc":"2.0","id":"telemetry-smoke","method":"tools/list","params":{}}'

/healthz should report "telemetry":{"analyticsEngine":"configured"}. Then query the commonlands_mcp_events Analytics Engine dataset. Column order is blob1=request method, blob2=path, blob3=MCP method, blob4=tool, blob5=status, blob6=client, blob7=environment, blob8=version, double1=HTTP status, and double2=duration ms.

Tool usage rollup:

bash
curl "https://api.cloudflare.com/client/v4/accounts/$CLOUDFLARE_ACCOUNT_ID/analytics_engine/sql" \  -H "Authorization: Bearer $CLOUDFLARE_ANALYTICS_READ_TOKEN" \  --data "SELECT blob4 AS tool, blob5 AS status, SUM(_sample_interval) AS calls, SUM(_sample_interval * double2) / SUM(_sample_interval) AS avg_duration_ms FROM commonlands_mcp_events WHERE timestamp >= NOW() - INTERVAL '7' DAY AND blob3 = 'tools/call' GROUP BY tool, status ORDER BY calls DESC LIMIT 50 FORMAT JSON"

Client/tool rollup:

bash
curl "https://api.cloudflare.com/client/v4/accounts/$CLOUDFLARE_ACCOUNT_ID/analytics_engine/sql" \  -H "Authorization: Bearer $CLOUDFLARE_ANALYTICS_READ_TOKEN" \  --data "SELECT blob6 AS client, blob4 AS tool, SUM(_sample_interval) AS calls, SUM(_sample_interval * double2) / SUM(_sample_interval) AS avg_duration_ms FROM commonlands_mcp_events WHERE timestamp >= NOW() - INTERVAL '7' DAY AND blob3 = 'tools/call' AND blob5 = 'ok' GROUP BY client, tool ORDER BY calls DESC LIMIT 100 FORMAT JSON"

Use blob4 to see which MCP tools agents actually call. High-call/high-success tools are candidates for deeper investment; low-call or repeated-error tools are candidates for better descriptions, consolidation, or deprecation. Keep Cloudflare invocation logs enabled for request/response metadata, but use Analytics Engine for tool-level decisions because it captures the JSON-RPC method and tool name without storing request arguments.

Starting with 0.4.2, failed connector operations also set MCP isError: true and record tool_error_not_configured, tool_error_invalid_request, tool_error_shopify_error, or tool_error_delivery_failed in blob5. Successful RFQ previews still count as successful calls; they do not mean an email was delivered. Client labels describe software, not unique people.

Earlier versions recorded these application failures as ok, so historical success rates can be overstated. Their true outcomes cannot be reconstructed from this dataset, because it deliberately excludes request/response payloads. Filter by blob8 (deployed version) when comparing corrected success rates.

Quick client setup

Codex

toml
[mcp_servers.commonlands]url = "https://mcp.commonlands.com/mcp"tool_timeout_sec = 60

Claude Desktop / Claude Code via mcp-remote

json
{  "mcpServers": {    "commonlands": {      "command": "npx",      "args": ["-y", "mcp-remote", "https://mcp.commonlands.com/mcp"]    }  }}

Cursor

json
{  "mcpServers": {    "commonlands": {      "url": "https://mcp.commonlands.com/mcp"    }  }}

Configuration

Non-secret config lives in wrangler.toml [vars]; credentials are Worker secrets set via the Cloudflare dashboard or wrangler secret put (never committed).

SettingWherePurpose
account_idwrangler.tomlPins the Cloudflare account so deploys do not call /memberships (which an account-scoped API token cannot access, surfacing as auth error 9106).
FOV_LIVE_BACKEND_ENABLED[vars]"true" routes FoV through the live Lambda backend.
FOV_LAMBDA_ENDPOINT[vars]Allowlisted FoV Lambda/API Gateway URL.
FOV_BACKEND_SCANS_FULL_CATALOG[vars]"true" makes compute_fov_catalog omit partNums so the Lambda scans its full DynamoDB lens table. Requires ALLOW_LENS_SCAN=true on the Lambda. When "false", the Worker sends fixture SKUs as a fallback.
SENSOR_DDB_TABLE[vars]DynamoDB sensor table name.
SENSOR_DDB_REGION[vars]DynamoDB sensor table region.
FOV_API_KEYsecretShared key the Worker sends to the FoV Lambda (x-api-key); must match the Lambda's FOV_API_KEY exactly (byte-for-byte, no trailing newline).
AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEYsecretRead-only IAM user credentials the Worker uses to read the sensor DynamoDB table (SigV4).
CLOUDFLARE_API_TOKENGitHub Actions secretToken with Workers Scripts: Edit used by the Deploy workflow.

AWS / DynamoDB notes

  • The Worker reads the sensor table directly with a read-only IAM user (only dynamodb:Scan/Query/GetItem/DescribeTable on that table ARN). No write actions exist in the code path.
  • The FoV Lambda reads the lens table with its own read-only execution role. For compute_fov_catalog full-catalog coverage the Lambda needs ALLOW_LENS_SCAN=true and dynamodb:Scan on the lens table.
  • Sensor table partition key is the part number (id); attributes used: sensormfg, sensorhpix, sensorvpix, sensorpitch, sensortype (shutter type).
  • Lens table partition key is the SKU; the Lambda's LENS_PK must be set accordingly.

Local development

Requirements: Node.js 22+.

bash
npm installnpm run verifynpm run dev

Local smoke test:

bash
curl http://localhost:8787/healthzcurl -X POST http://localhost:8787/mcp \  -H 'content-type: application/json' \  -H 'accept: application/json, text/event-stream' \  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

Deploy

Production deployment is manual from a trusted computer using Wrangler's browser OAuth login. GitHub runs checks only; no Cloudflare deployment token is required in GitHub Actions. Merge the reviewed release branch and pull it before deploying. The source wrangler.toml intentionally does not define local build metadata.

powershell
npm cinpm run verify# Clear token overrides in this terminal so Wrangler uses browser OAuth.Remove-Item Env:CLOUDFLARE_API_TOKEN, Env:CF_API_TOKEN, Env:CLOUDFLARE_API_KEY, Env:CF_API_KEY -ErrorAction SilentlyContinuenpx wrangler loginnpx wrangler whoaminpm run deployInvoke-RestMethod https://mcp.commonlands.com/healthz

Stop if any command fails. Confirm whoami has access to the account in wrangler.toml. After deployment, confirm /healthz reports the expected version and Git commit, then run the client smoke tests in docs/client-connections.md.

npm run deploy runs scripts/deploy.mjs, which deploys with --keep-vars and injects the same production build metadata. npm run deploy:raw is the unwrapped Wrangler deploy command.

Wrangler stores OAuth credentials locally outside the repository. Never commit credentials. The retired GitHub CLOUDFLARE_API_TOKEN secret can be removed in repository Settings > Secrets and variables > Actions; deleting the workflow does not delete stored secrets. The separate analytics token is not a deployment credential. See Wrangler authentication.

License and private backend

Apache-2.0 covers the Commonlands-owned source code distributed in this repository. The separately hosted Commonlands Lambda implementation and private optical datasets are not distributed or licensed under this repository's license. Applicable third-party licenses and notices remain in effect.

The public MCP endpoint provides access to the hosted service without requiring its backend source code. Users connect to https://mcp.commonlands.com/mcp; the service calls the private Lambda backend using server-side credentials. Independently hosting this adapter requires an authorized compatible backend; the source-code license does not grant backend credentials or access to private code or datasets.

Source: README.md at commit 659c3a8

Tools

21

calculate_field_of_view

Calculate Commonlands field of view

Calculate Commonlands lens field of view for a lens/sensor pair and return HFOV, VFOV, DFOV, coverage, distortion status, and an explicit rectilinear comparison. Use this tool for FOV, HFOV, VFOV, DFOV, field of view, "lens for", lens-to-sensor, AR0234, IMX290, IMX477, and sensor part-number requests. It returns Commonlands data the model cannot derive: live backend FoV when configured, distortion model/status, image-circle coverage, live stock through Shopify read tools where applicable, and MTF/CRA/BFL fields if present in upstream catalog data. Do not use naive rectilinear fallback, focal-length-only math, interpolation, or self-computed catalog estimates when a Commonlands lens/sensor route is available. Accepts lens_sku/lensSku or focal_length_mm/focalLengthMm, plus sensor/sensorPartNumber/sensor_part_number and working_distance_mm/workingDistanceMm. No part number? Describe the sensor directly: widthPx + heightPx + pixelSizeUm (active area is derived as pixels x pitch), or sensorWidthMm + sensorHeightMm. Results are labelled CUSTOM-<w>x<h>. If only focal length is supplied, the response is marked as a rectilinear reference and does not claim Commonlands distortion-corrected lens truth.

ParameterssensorlensSkuwidthPxheightPxlens_skupixelSizeUmpixelPitchUmfocalLengthMmsensorWidthMmsensorHeightMmverticalPixelsfocal_length_mm+5 more

match_lens_to_sensor

Match Commonlands lenses to a sensor

Find and rank Commonlands lenses for a sensor, target field of view, working distance, mount, or "lens for" request. Use this tool for FOV, HFOV, VFOV, DFOV, field of view, "lens for", lens-to-sensor, AR0234, IMX290, IMX477, and sensor part-number requests. It returns Commonlands data the model cannot derive: live backend FoV when configured, distortion model/status, image-circle coverage, live stock through Shopify read tools where applicable, and MTF/CRA/BFL fields if present in upstream catalog data. Do not use naive rectilinear fallback, focal-length-only math, interpolation, or self-computed catalog estimates when a Commonlands lens/sensor route is available. Use this for AR0234, IMX290, IMX477, sensor part numbers, M12/C-mount matching, and target HFOV/VFOV/DFOV workflows; do not shortlist from focal length alone. No part number? Describe the sensor directly: widthPx + heightPx + pixelSizeUm (active area is derived as pixels x pitch), or sensorWidthMm + sensorHeightMm. Results are labelled CUSTOM-<w>x<h>. Use read_shopify_products afterward for live stock, price, availability, Shopify variantId, product URL, and metafields.

ParametersmountsensorwidthPxheightPxmaxResultsmax_resultspixelSizeUmpixelPitchUmsensorWidthMmsensorHeightMmverticalPixelshorizontalPixels+6 more

search_lens_catalog

Search Commonlands lens catalog

Search the Commonlands lens catalog by SKU, mount, lens type, M12, C-mount, or application text. For sensor part numbers such as AR0234, IMX290, and IMX477, or any "lens for <sensor>" request, use match_lens_to_sensor instead — sensor names are not searchable text here. Use this tool for FOV, HFOV, VFOV, DFOV, field of view, "lens for", lens-to-sensor, AR0234, IMX290, IMX477, and sensor part-number requests. It returns Commonlands data the model cannot derive: live backend FoV when configured, distortion model/status, image-circle coverage, live stock through Shopify read tools where applicable, and MTF/CRA/BFL fields if present in upstream catalog data. Do not use naive rectilinear fallback, focal-length-only math, interpolation, or self-computed catalog estimates when a Commonlands lens/sensor route is available. This discovers candidate lenses from Commonlands catalog/live backend data; it does not replace calculate_field_of_view for sensor-specific HFOV/VFOV/DFOV and does not replace read_shopify_products for live stock/price/product truth.

Parameterslimitquery

get_lens_distortion_profile

Get Commonlands lens distortion profile

Return the Commonlands distortion model/status for one lens SKU, including whether the data is source-display-only or backend-calculated. Use this tool for FOV, HFOV, VFOV, DFOV, field of view, "lens for", lens-to-sensor, AR0234, IMX290, IMX477, and sensor part-number requests. It returns Commonlands data the model cannot derive: live backend FoV when configured, distortion model/status, image-circle coverage, live stock through Shopify read tools where applicable, and MTF/CRA/BFL fields if present in upstream catalog data. Do not use naive rectilinear fallback, focal-length-only math, interpolation, or self-computed catalog estimates when a Commonlands lens/sensor route is available. Use this for distortion, rectilinear-vs-wide-angle, MTF/CRA/BFL/optical-profile questions when upstream fields are present. Do not invent polynomial coefficients or claim measured distortion correction when the backend only returns display distortion.

ParametersskulensSkulens_sku

get_sensor_specs

Get sensor specs

Return sensor dimensions, pixel pitch, and resolution for lens field of view, M12 lens, and C-mount lens matching inputs. In production this uses the read-only live sensor table when configured, with fixture fallback when unavailable. Use these specs as inputs to calculate_field_of_view or match_lens_to_sensor, not as a reason to hand-calculate FoV. FoV rule: never estimate sensor-specific FoV from catalog fields; use calculate_field_of_view or match_lens_to_sensor.

ParameterspartNumberrequired

compare_lenses

Compare Commonlands lenses

Compare selected Commonlands M12 lens and C-mount lens SKUs on the same sensor with the same deterministic scoring model. Use as explanatory context, then call calculate_field_of_view for final sensor-specific FoV values when precision matters. FoV rule: never estimate sensor-specific FoV from catalog fields; use calculate_field_of_view or match_lens_to_sensor. Not live product truth; verify purchasable facts with read_shopify_products.

ParameterslensSkusrequiredsensorPartNumberrequiredworkingDistanceMm

get_product_page_details

Get product page details

Return fixture-backed product-page handoff details for one lens, including DynamoDB-sourced optical specs and gated datasheet policy. Product-page/catalog optical fields are not a substitute for sensor-specific FoV; call calculate_field_of_view for the lens/sensor pair. FoV rule: never estimate sensor-specific FoV from catalog fields; use calculate_field_of_view or match_lens_to_sensor. Use read_shopify_products for live product URL, price, availability, variant IDs, and metafields.

Parametersskurequired

get_catalog_snapshot_status

Get joined catalog snapshot status

Return fixture-backed joined catalog counts, validation status, source provenance, live connector readiness, and non-authoritative product-truth warning.

Takes no parameters.

get_shopify_ucp_readiness

Get Shopify Storefront/UCP readiness

Report connector-free Shopify Storefront MCP and UCP Catalog compatibility, launch blockers, and Commonlands engineering differentiators.

Takes no parameters.

get_shopify_readonly_config_status

Get Shopify read-only config status

Report sanitized Cloudflare Shopify binding presence, approved read scopes, and read-only safety flags without exposing secrets or calling Shopify.

Takes no parameters.

read_shopify_products

Read Shopify products

Use this for live purchasable product truth: product and variant IDs, SKUs, prices, coarse availability, product URLs, and public product-page metafields. Public data only: active products, no exact inventory counts, and metafields limited to the custom.* display fields shown on commonlands.com product pages. Read-only; does not create carts, checkouts, orders, customers, inventory mutations, or Shopify writes. Fixture catalog tools are scaffold data only.

ParametersskulimitqueryhandleincludeMetafields

create_cart

Create Shopify cart

Create a Shopify-owned cart for selected variant line items through the configured Shopify Cart/Storefront MCP endpoint. Commonlands MCP is a stateless proxy: cart state is stored and mutated by Shopify, not in the Worker. The response includes a cart_access_token that binds the cart to this session; retain it, because get_cart and update_cart refuse to act on the cart without it.

Parameterscartrequiredmeta

get_cart

Get Shopify cart

Retrieve a Shopify-owned cart by cart id. Owner-bound: requires the cart_access_token returned by create_cart, so only the session that created a cart can read it. Cart persistence comes from Shopify; agents must retain the cart id, cart_access_token, and continue_url across sessions.

Parametersidrequiredmetacart_access_tokenrequired

update_cart

Update Shopify cart

Update a Shopify-owned cart through the configured Cart/Storefront MCP endpoint. Owner-bound: requires the cart_access_token returned by create_cart, so only the session that created a cart can change it. With UCP endpoints, treat updates as full-state PUT semantics; with the confirmed standard Storefront MCP endpoint, Commonlands maps line_items to Shopify add_items, update_items to quantity changes, and remove_line_ids to explicit removals. Quantity 0 in update_items removes a line.

Parametersidrequiredcartrequiredmetacart_access_tokenrequired

search_catalog

Search UCP catalog

Fixture-backed UCP Catalog search alias for Shopify-native product discovery; no live Shopify calls or cart behavior. Use this only for broad discovery; when a sensor or target FoV is involved, call match_lens_to_sensor or calculate_field_of_view instead of estimating from catalog fields. FoV rule: never estimate sensor-specific FoV from catalog fields; use calculate_field_of_view or match_lens_to_sensor.

Parametersmetacatalog

lookup_catalog

Lookup UCP catalog products

Fixture-backed UCP Catalog lookup alias for product, variant, SKU, handle, or URL identifiers; returns not-found messages instead of writes. Lookup records are not enough for sensor-specific FoV; call calculate_field_of_view for known lens/sensor pairs. FoV rule: never estimate sensor-specific FoV from catalog fields; use calculate_field_of_view or match_lens_to_sensor.

Parametersmetacatalogrequired

get_product

Get UCP catalog product

Fixture-backed UCP Catalog product detail alias with Commonlands optical metadata and Shopify-native handoff fields. Product optical fields are not a substitute for sensor-specific FoV; call calculate_field_of_view for the lens/sensor pair. FoV rule: never estimate sensor-specific FoV from catalog fields; use calculate_field_of_view or match_lens_to_sensor.

Parametersmetacatalogrequired

prepare_shopify_purchase_handoff

Prepare Shopify purchase handoff

Build a read-only Shopify-native purchase handoff seam for a selected lens without creating carts, checkout, orders, inventory mutations, or writes. Preserve any computed FoV provenance from calculate_field_of_view/match_lens_to_sensor when carrying optical context into purchase handoff. FoV rule: never estimate sensor-specific FoV from catalog fields; use calculate_field_of_view or match_lens_to_sensor.

ParametersskurequiredquantitysensorPartNumberselectedVariantId

get_purchase_route_options

Get purchase route options

Return safe dual-channel purchase route options for AI agents and robotics engineers across Commonlands MCP and Shopify-native channels without mutating commerce state. This explains commerce routes only; call calculate_field_of_view/match_lens_to_sensor for sensor-specific FoV before recommending a lens. FoV rule: never estimate sensor-specific FoV from catalog fields; use calculate_field_of_view or match_lens_to_sensor.

ParametersskurequiredquantityagentTypebuyerIntentsensorPartNumber

recommend_lenses_for_application

Recommend lenses for an application

Rank Commonlands M12 lenses and C-mount lenses for an application note such as embedded robotics, machine-vision inspection, or a required lens field of view. Use as an application shortlist helper, then call match_lens_to_sensor or calculate_field_of_view for final per-sensor HFOV/VFOV/DFOV. FoV rule: never estimate sensor-specific FoV from catalog fields; use calculate_field_of_view or match_lens_to_sensor.

ParametersmountmaxResultsapplicationrequireInStocksensorPartNumberrequiredworkingDistanceMmpreferLowDistortiondesiredHorizontalFovDeg

submit_rfq

Submit an RFQ or question to Commonlands

Forward a buyer request-for-quote or engineering question to the Commonlands engineering team. Two-step, buyer-confirmed: the first call returns a preview and sends nothing; show the buyer the preview (including their reply-to email) and, only after they explicitly approve, call again with confirm: true to send. The recipient is fixed to the Commonlands inbox (the agent cannot choose it); this only sends an inquiry and never creates an order, charges a card, or writes Shopify/customer data. Include part numbers, sensor, quantity, and application when known so the team can reply with a quote. Commonlands replies by email.

ParameterskindnameemailrequiredsensorcompanyconfirmmessagerequiredquantityapplicationpartNumbers

Version history

2
  1. v0.4.2LatestOct 20, 2026
  2. v0.4.0Sep 16, 2026

Score

100% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts