TableTalk MCP server
Commit Oct 23, 2026An intelligent restaurant assistant that enables voice-driven dining interactions, table negotiations, allergen-aware menu searches, and bookings.
Also known as dhanushkumar-amk/TableTalk
- Stars
- 1
- Tools
- 24
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Oct 23, 2026
- License
- MIT
What is TableTalk MCP?
TableTalk is an intelligent restaurant assistant that enables voice-driven dining interactions, table negotiations, allergen-aware menu searches, and bookings. It exposes 24 tools, such as ping_restaurant, search_menu, check_availability.
Summary generated from the project's README
About TableTalk MCP server
Managing restaurant reservations and dining preferences through voice-driven interfaces is what TableTalk enables for developers building intelligent assistants. This MCP server provides a complete suite of 24 tools designed to handle the entire dining lifecycle, from searching allergen-safe menus to negotiating table availability when a preferred time slot is fully booked. It is built with Rust and uses SQLite for persistence, making it suitable for low-latency, single-instance deployments.
Developers can integrate this server with clients using Groq Llama 3.3 70B or Amazon Bedrock with Amazon Nova Lite. The system includes specialized features like five-minute atomic table holds using cryptographic tokens to prevent booking conflicts during a conversation. While it manages complex logic like integer-based currency arithmetic and privacy-preserving memory, it maintains strict security by requiring human confirmation for all payments through secure links rather than handling card data directly.
What you can do with it
- 1Search for safe menu itemsFind food options that comply with specific dietary restrictions and allergy concerns.
- 2Secure a temporary table holdPlace a short-term hold on a table to finalize a booking during a conversation.
- 3Manage personal dining preferencesInstruct the assistant to remember or delete your specific dietary needs and favorite seating.
Written from the project's README. Every use case is checked against a quote from it.
TableTalk MCP tools 24
Detected from the READMEping_restaurantsearch_menucheck_availabilitycreate_bookingget_bookingcancel_bookingnegotiate_bookingaccept_offerrelease_offerjoin_waitlistget_waitlist_statusleave_waitlist
Show all 24 toolsShow fewer tools
place_orderget_ordercancel_orderget_deposit_statusrefresh_payment_sessionsimulate_deposit_paymentenable_memoryget_profileremember_preferenceforget_preferenceget_usual_orderforget_me
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachabledhanushkumar-amk/tabletalk is public and reachablegithub.com/dhanushkumar-amk/tabletalk ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-10-23github.com/dhanushkumar-amk/tabletalk ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model24 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubTableTalk
Intelligent restaurant assistant MCP server powering voice-driven dining interactions, capacity negotiation, allergen-safe search, and frictionless bookings.
TableTalk is a production-hardened restaurant server implementing the Model Context Protocol (MCP) over Streamable HTTP (spec version 2025-11-25). Built in Rust with Axum, Tokio, and SQLite WAL persistence, it pairs with a React assistant frontend that renders accessible UI cards for voice assistants like Amazon Alexa+.
Architecture & System Design
TableTalk features complete High-Level Design (HLD), Low-Level Concurrency Architecture (LLD), Sequence Flows, and User Journeys. A publication-ready 6-page landscape PDF is available at: 👉 TableTalk_System_Design_Specification.pdf (also documented in docs/SYSTEM_DESIGN_SPECIFICATION.md)
High-Level Design (HLD)

Low-Level Design & Concurrency Controller (LLD)

Conversational Sequence Flow

User Flow & Dining Journey

User Stories & Persona Journey Maps

Features
- 24 Compliant MCP Tools: Covers full dining lifecycle across 5 distinct domains.
- Smart Dining Room Negotiation: Evaluates table inventories, detects fully booked slots, and returns deterministically ranked alternatives with explainable scoring.
- Short-Lived Table Holds: Places 5-minute atomic holds with cryptographic offer tokens to prevent table snatching during conversation turns.
- Uncompromising Allergen Safety: Prohibits false safety claims (
guaranteed,allergy-free), flags cross-contact risks, and requires explicit diner confirmation. - Integer Paise Money Arithmetic: Eliminates floating-point currency drift with overflow-checked minor units.
- Privacy-Preserving Memory: Remembers dining preferences only with explicit consent; stores profile tokens as SHA-256 hashes; provides permanent "Forget Me" hard deletion.
- The Human-Confirms Payment Rule: The AI assistant never handles card data or approves payments; all deposits require human confirmation through secure links.
- Dual LLM Provider Support: Native tool calling with Groq Llama 3.3 70B (sub-300ms time-to-first-token) and Amazon Bedrock with Amazon Nova Lite (
apac.amazon.nova-lite-v1:0). - Reliable Scripted Demo Router: When running locally without live LLM API keys (labeled "Scripted demo" in the UI), TableTalk operates via a deterministic, multi-turn scripted router. It executes the real, underlying Rust MCP tools, SQLite transactions, allergen checks, and card payloads under the hood—ensuring zero video hallucination and reproducible test coverage.
Quick Start
Option A: Local Development
1. Prerequisites
- Rust stable toolchain (
1.80+) - Node.js
20+LTS - Git & curl
2. Start Backend
# Runs migrations, applies deterministic seed data, and listens on port 8080
cargo run --manifest-path backend/Cargo.toml --bin mcp_tabletalk_backend
3. Start Frontend
cd frontend
npm install
npm run dev
Open http://localhost:5173/assistant in your browser.
4. Verify Health & Readiness
curl http://localhost:8080/health
# {"status":"ok"}
curl http://localhost:8080/ready
# {"status":"ready","database":"connected"}
Option B: Docker Compose
Run both the backend and frontend with a single command:
docker compose up --build
- Backend: http://localhost:8080
- Frontend: http://localhost:5173
Option C: Inspecting Tools via MCP Inspector
Launch the official Model Context Protocol Inspector:
npx --yes @modelcontextprotocol/inspector
- Open the inspector URL displayed in terminal (e.g.
http://127.0.0.1:6274). - Add server: Transport: Streamable HTTP, URL:
http://127.0.0.1:8080/mcp. - Test all 24 tools live!
Configuration
All configuration is loaded from environment variables (or .env file) with safe defaults and fail-fast validation:
| Variable | Default | Purpose |
|---|---|---|
PORT |
8080 |
Port for Axum HTTP and MCP server |
ALLOWED_ORIGINS |
http://localhost:5173,http://127.0.0.1:5173,http://localhost:8080,http://127.0.0.1:8080 |
Origin allowlist to prevent DNS rebinding |
RUST_LOG |
info,tabletalk_backend=debug |
Tracing log filter |
DATABASE_URL |
sqlite://data/tabletalk.db |
SQLite database URI |
SEED_ON_START |
false |
Idempotently seeds initial restaurant data if empty |
RESTAURANT_TZ |
Asia/Kolkata |
Restaurant timezone for capacity scheduling |
REQUEST_TIMEOUT_SECS |
30 |
Request timeout ceiling |
RATE_LIMIT_PER_MINUTE |
600 |
Per-IP rate limit for general endpoints |
LLM_PROVIDER |
groq |
Conversational inference provider (groq or bedrock) |
GROQ_API_KEY |
(None) | API key for Groq Cloud |
GROQ_MODEL |
llama-3.3-70b-versatile |
Model name for Groq completions |
AWS_REGION |
ap-south-1 |
AWS Region for Amazon Bedrock runtime |
BEDROCK_MODEL_ID |
apac.amazon.nova-lite-v1:0 |
Bedrock inference model profile |
CHAT_MAX_TOKENS |
500 |
Output token limit per chat turn |
CHAT_SESSION_TOKEN_BUDGET |
10000 |
Token limit per chat session |
CHAT_DAILY_TOKEN_BUDGET |
50000 |
Daily token circuit breaker |
CHAT_RATE_LIMIT_PER_MINUTE |
30 |
Per-IP rate limit for conversational chat endpoint |
CHAT_MAX_MESSAGE_LEN |
1000 |
Maximum character length for user chat prompts |
MCP Tools Reference
TableTalk registers 24 compliant tools with JSON Schema Draft 2020-12 inputs and outputs:
| Tool Name | Domain | Annotations | Description |
|---|---|---|---|
ping_restaurant |
Core | read_only |
Liveness and connectivity check returning restaurant name and clock. |
search_menu |
Menu | read_only |
Allergen-aware menu search with dietary filters and transparent cross-contact notices. |
check_availability |
Availability | read_only |
Real-time dining table capacity check for requested party size and time. |
create_booking |
Booking | idempotent |
Confirm reservation directly when table is open. |
get_booking |
Booking | read_only |
Retrieve existing reservation status by confirmation code. |
cancel_booking |
Booking | destructive |
Cancel an active table reservation. |
negotiate_booking |
Negotiation | read_only |
Evaluate fully-booked slots and return ranked alternative options with scores. |
accept_offer |
Negotiation | idempotent |
Place a 5-minute hold on a negotiated option or convert hold to confirmed booking. |
release_offer |
Negotiation | destructive |
Manually release an active table hold before expiration. |
join_waitlist |
Waitlist | idempotent |
Join FIFO dining waitlist for preferred time window. |
get_waitlist_status |
Waitlist | read_only |
Check waitlist position and inspect table offers. |
leave_waitlist |
Waitlist | destructive |
Remove party from dining waitlist. |
place_order |
Ordering | idempotent |
Place pickup order with checked paise pricing and prep time estimation. |
get_order |
Ordering | read_only |
Retrieve pickup order status and item breakdown. |
cancel_order |
Ordering | destructive |
Cancel pickup order prior to kitchen preparation cutoff. |
get_deposit_status |
Deposits | read_only |
Check status of deposit requirement for peak reservations. |
refresh_payment_session |
Deposits | idempotent |
Regenerate payment link for pending deposits. |
simulate_deposit_payment |
Deposits | idempotent |
Simulated human payment confirmation (mock checkout). |
enable_memory |
Memory | idempotent |
Opt in to preference memory with explicit diner consent. |
get_profile |
Memory | read_only |
Retrieve stored dining preferences using profile token. |
remember_preference |
Memory | idempotent |
Save dietary preference or favorite seating area. |
forget_preference |
Memory | destructive |
Delete a single stored preference record. |
get_usual_order |
Memory | read_only |
Retrieve personalized frequent order recommendation re-validated against live menu. |
forget_me |
Memory | destructive |
Hard delete guest profile, all preferences, and scrub PII. |
Testing & Quality Assurance
TableTalk is comprehensively tested across 16 integration suites, fuzz testing, and protocol verification:
# 1. Rust Formatting & Lints
cargo fmt --check
cargo clippy --all-targets -- -D warnings
# 2. Rust Unit & Integration Tests (110 tests)
cargo test
# 3. Frontend Lint, Typecheck, and Unit Tests (83 tests)
cd frontend
npm run lint
npm test -- --run
npm run build
cd ..
# 4. MCP Protocol Smoke Tests & Inspector CLI
./scripts/smoke-test.sh
# 5. Security & Secret Scan over Full Git History
node scripts/secret-scan.cjs
# 6. Database Point-in-Time Backup Test
./scripts/backup.sh
Demo Script
Follow the step-by-step 3-minute recording script in docs/DEMO_RUNBOOK.md, including:
- 0:00 - 0:30: The Hook (Voice Negotiation on Fully Booked Friday 7:30 PM slot)
- 0:30 - 1:00: Table Confirmation & Interactive Booking Card
- 1:00 - 1:45: Allergy-Aware Menu Search (Vegan & Peanut Exclusion)
- 1:45 - 2:25: Pickup Order Placement & Prep Tracking
- 2:25 - 2:50: Privacy & "Forget Me" Hard Memory Scrubbing
- 2:50 - 3:00: Architecture Wrap-Up
Hackathon Submission & Technical Documentation
- Event: Amazon Developer Hackathon (Alexa+ Track)
- Architecture & System Design: Complete HLD, LLD, and user journeys in docs/SYSTEM_DESIGN_SPECIFICATION.md and docs/TableTalk_System_Design_Specification.pdf.
- Submission Document: Complete copy-paste submission kit available in docs/SUBMISSION.md.
- Product Feedback: Full five-question platform feedback for the Rust MCP SDK, Streamable HTTP, SQLx, and AWS Bedrock available in docs/PRODUCT_FEEDBACK.md.
- Friction Log: Chronological engineering obstacles and workarounds in docs/FRICTION_LOG.md.
- Production Gap Analysis: Honest appraisal of demo state vs enterprise production in docs/PRODUCTION_READINESS.md.
Limitations
- Simulated Payments: Financial transactions use mock checkout links; no real credit card networks are touched.
- Single-Node SQLite: Designed for low-latency single-instance embedded use with WAL mode.
- Polling-Only Waitlist: Waitlist notifications are checked on demand via
get_waitlist_status. - Alexa+ Custom Visual Cards: Alexa+ third-party custom UI card rendering on Echo Show hardware is UNVERIFIED due to pre-release developer guidelines; SSML and spoken voice formatting are 100% verified.
License
This project is licensed under the MIT License.
Copyright (c) 2026 Dhanush Kumar (TableTalk Contributors)
TableTalk MCP questions
What tools does TableTalk MCP provide?
It exposes 24 tools, including ping_restaurant, search_menu, check_availability, create_booking, get_booking.
How does the server handle payments?
The AI assistant never handles card data or approves payments; all deposits require human confirmation through secure links.
Can the AI guarantee food is allergy-free?
No, the system prohibits false safety claims and instead flags cross-contact risks while requiring explicit diner confirmation.
How is user privacy managed regarding dining preferences?
Users must explicitly consent to memory, profile tokens are stored as SHA-256 hashes, and a 'Forget Me' feature allows for permanent hard deletion.
Does the server support real credit card transactions?
No, financial transactions use simulated mock checkout links and do not touch real credit card networks.