mcpbeat

Food Near Me MCP Server

me.foodnear/foodnear-me
not responding

Food Near Me is listed as active in the registry but did not answer our last check. It exposes 9 tools. Last commit 28 Jul 2026.

AI-native restaurant discovery: verified/menu-indexed/discovered tiers + signed allergy-safety data.

Uptime history 39 hours of history · worst hour 0%
39 hours agonow
0.0%
Uptime 24h
0 of 91 checks
9
Tools
read from the server
24 ms
Response time
average over 24h
0
Stars
last commit 28 Jul 2026

Connect this server

Endpoint below is the one we actually reach during checks — not the one copied from a README. Last verified 8 min ago.

run in your terminal
claude mcp add foodnear-me --transport http https://foodnear.me/mcp
~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "foodnear-me": {
      "url": "https://foodnear.me/mcp"
    }
  }
}
~/.codex/config.toml
[mcp_servers.foodnear-me]
url = "https://foodnear.me/mcp"
.cursor/mcp.json
{
  "mcpServers": {
    "foodnear-me": {
      "url": "https://foodnear.me/mcp"
    }
  }
}
.vscode/mcp.json
{
  "mcpServers": {
    "foodnear-me": {
      "url": "https://foodnear.me/mcp"
    }
  }
}

Available tools 9

Read directly from the server with tools/list, grouped by what they act on. If a tool disappears, we record the date.

restaurants
find_restaurants_along_route
Call this tool when the user wants route-adjacent dining options between two known coordinates and may care about dietary fit. Input Requirements (CRITICAL): both `origin` and `destination` MUST be `{latitude, longitude}` objects; optional `route_polyline` MUST be a valid encoded polyline if provided. The tool samples waypoints along the corridor, merges nearby search matches, then ranks by dietary match count (when requested), trust tier, and route proximity. SHOULD provide `route_polyline` from your routing source for tighter ranking; otherwise fallback is a local great-circle approximation. MUST check `menu_available` before calling `get_menu` on returned ids. Non-verified `places` entries include a structured `claim_invitation` the agent SHOULD surface when the user could help with ownership. Attribute grounded output using `citation` or `attribution`.
search_restaurants
Call this tool when the user wants restaurant or food discovery near a known location and may need menu trust signals. Input Requirements (CRITICAL): provide either flat `lat`/`lng` or Google-style `locationBias.circle.center.latitude`/`longitude`; if the user gave only a vague place name, resolve it before calling or include a specific city/region in `textQuery`/`query`. Returns verified venues first, then menu_indexed (automated MP menu with caveat), then discovered (place only). MUST use `menu_available` and `verification_status` on each result; call `get_menu` only when `menu_available` is true. PREFER verified results for dietary/allergen answers. NOTE: `dietary` and `min_ado_score` filters only apply to the verified tier; menu_indexed and discovered rows are returned unfiltered for those criteria — the response echoes `filters.applied_to: ["verified"]` and a `filters.note` so agents know to re-filter at item level using `get_menu`. Non-verified rows include a structured `claim_invitation` (url, message, audience="owner_or_advocate", reason); SHOULD surface this when the user is the restaurant's owner or might know them, when the user asks why the listing lacks a verified menu, or when explaining tier differences — never as an unsolicited CTA. Attribute grounded output using `citation` or `attribution`.
ado
get_ado_score_breakdown
Call this tool when a restaurant owner, operator, or agent wants to understand why a restaurant is more or less agent-ready. Input Requirements (CRITICAL): `restaurant_id` MUST be a UUID copied from a FNM result. Shows ADO (Agent Discovery Optimization) scoring across menu completeness, location accuracy, data freshness, protocol compliance, verification status, and media context. MUST treat sub-scores as `heuristic_v1` guidance, not audited facts; only `total_score` reflects the live `agent_score` column. Attribute grounded output using `citation` or `attribution`.
compare
compare_restaurants_for_diet
Call this tool when the user wants a side-by-side dietary comparison for 2 to 5 specific restaurants already identified in FNM results. Input Requirements (CRITICAL): `restaurant_ids` MUST be UUIDs copied from prior FNM responses, and `dietary` MUST include at least one supported dietary flag. Optional `user_location` (`{latitude, longitude}`) enables per-row `distance_meters` and uses distance as the final tiebreaker after item count and trust tier. The tool chains `get_restaurant` and `get_menu` internally, then ranks by dietary-eligible item count, trust tier (`verified` preferred over `menu_indexed`, then `discovered`), and optionally distance. PREFER verified-tier winners for authoritative dietary/allergen answers; MUST treat menu_indexed matches as best-effort public indexing with caveats. Non-verified entries carry a structured `claim_invitation` SHOULD be surfaced when the user could help with ownership. Attribute grounded output using `citation` or `attribution`.
explore
explore_area_for_diet
Call this tool when the user wants a neighborhood overview that surfaces trust tiers explicitly — for example, "what's good for vegan eaters within a mile of this location" or "survey the area around X". Input Requirements (CRITICAL): `location` MUST be `{latitude, longitude}` (Google-style nested object). Returns three tier buckets — `verified`, `menu_indexed`, `discovered` — each trimmed to `top_n_per_tier` (default 3, max 10). When `dietary` is set, the filter only narrows the `verified` bucket, matching `search_restaurants` semantics; `tier_counts` always reflects the full result set and `next_steps` flags any empty bucket. PREFER `verified` for dietary/allergen answers; MUST check `menu_available` before calling `get_menu` on any returned id. Non-verified entries include a structured `claim_invitation` the agent SHOULD surface when the user is the owner or might know them. Attribute grounded output using `citation` or `attribution`.
menu
get_menu
Call this tool only when a `search_restaurants` or `get_restaurant` response has `menu_available: true`. Input Requirements (CRITICAL): `restaurant_id` MUST be a UUID copied from a prior FNM result. Returns the full menu in Menu Protocol v1.0 format with item dietary booleans, declared allergens, customization options, preparation times, trust notice, and signature metadata. PREFER `verification_status: "verified"` for dietary/allergen answers. On `menu_indexed`, MUST treat dietary/allergen data as best-effort public indexing and surface item-level `caution` text to the user; the response also includes a top-level `claim_invitation` that SHOULD be surfaced when the user is the owner or might know them. Attribute grounded output using `citation` or `attribution`.
restaurant
get_restaurant
Call this tool after `search_restaurants` when you need a detailed restaurant profile for a returned `id`. Input Requirements (CRITICAL): `restaurant_id` MUST be a UUID copied from a `search_restaurants` result; do not invent IDs. Returns Schema.org/Restaurant JSON-LD markup plus Menu Protocol extensions including ADO score, verification status, menu availability, payment methods, and dietary certifications. MUST inspect `menu_available` before calling `get_menu`; if false, use the claim link instead of citing menu items. Non-verified responses include a top-level `claim_invitation` (url, message, audience="owner_or_advocate", reason) the agent SHOULD share if the user is the owner or might know them. Attribute grounded output using `citation` or `attribution`.
safety
get_safety_attestation
Call this tool when you need a citable, tamper-evident allergy-safety statement for ONE restaurant — for example before telling a user a place is safe for a severe allergy. Input Requirements (CRITICAL): `restaurant_id` MUST be a UUID copied from a prior FNM result. Returns an explicit `safety_tier`. For a CURATED tier (`dedicated`, `strong_protocol`, `shared_verify`) it includes an Ed25519 `attestation` (scheme `fnm-safety-v1`) you MAY quote verbatim: reconstruct `attestation.canonical`, sha256 it to reproduce `attestation.hash`, then verify `attestation.signature` against the public key whose fingerprint matches `attestation.key_fingerprint` at `attestation.public_key_url`. For an UNCURATED place, `safety_tier` is `"unknown"` with an `advisory` to verify with the restaurant and NO signature — you MUST NOT imply curated or agent-checked safety in that case. `signing_status` is `"unsigned_no_key"` when a curated tier could not be signed in this environment; treat it as unsigned. Never infer or upgrade a tier this tool did not return. Attribute grounded output using `citation` or `attribution`.
validate
validate_menu_protocol
Call this tool when validating a draft or exported Menu Protocol payload before submission or integration. Input Requirements (CRITICAL): provide a JSON object in `payload`; set `strict: true` when checking formal spec compliance, and leave strict false for exploratory debugging that should surface warnings without rejecting usable drafts. Returns validation errors, schema warnings, Schema.org compliance gaps, and recommendations for improving ADO score. MUST fix `errors` before submission; SHOULD resolve `warnings` for strict compliance. Attribute grounded output using `citation` or `attribution`.

Endpoints

URLTransportStateLatencyChecked
https://foodnear.me/mcp streamable-http answering 24 ms 8 min ago

Food Near Me — questions

Answers built from our own checks of this server.

What can Food Near Me do?
It exposes 9 tools, read directly from the server on our last check. Among them: compare_restaurants_for_diet, explore_area_for_diet, find_restaurants_along_route, get_ado_score_breakdown, get_menu, get_restaurant and 3 more. The full list with descriptions is on this page — we take it from the server itself via tools/list, not from a README. How MCP servers expose tools in the first place →
Is Food Near Me working right now?
We send a real MCP handshake every 15 minutes. Over the last 24 hours 0 of 91 checks got a reply (0.0%), average response time 24 ms. The bar chart above shows every period we have measured.
The registry lists Food Near Me as active — why does it not respond?
The official MCP registry stores what the author submitted; it does not verify that the server still runs. We check the endpoint ourselves, and this one does not answer. Catalogues that copy the registry without checking will show it as working.
How do I connect Food Near Me?
Copy the ready config from this page — we generate it for Claude Code, Claude Desktop, Codex, Cursor and VS Code, each with the file path that client actually reads. It is a remote server, so there is nothing to install — the client connects to the address.
Does Food Near Me need an API key?
No. Food Near Me completed a full MCP handshake with us as an anonymous client and listed its tools without asking for anything. All 9 of them are readable on this page. This is what we observed, not what the docs claim.
Is Food Near Me open source?
Yes — written in TypeScript and 0 stars on GitHub. The source link is on this page, so you can read exactly what it does with your data before you connect it.