Power your agent
คำสั่งของผู้เผยแพร่เอง ไม่ใช่เอนด์พอยต์ของ PlugMCP
Host a copy with our keys and logs.
npx -y @openbooking-sh/[email protected]Claude Code ไม่มีลิงก์ติดตั้งสำหรับคำสั่งแบบโลคัล ให้คัดลอกคำสั่งด้านล่างแล้วรันในเทอร์มินัล
claude mcp add openbooking-sh-postgres -- npx -y @openbooking-sh/postgres@0.12.0รันในเทอร์มินัล
{ "mcpServers": { "openbooking-sh-postgres": { "command": "npx", "args": [ "-y", "@openbooking-sh/[email protected]" ] } }}claude_desktop_config.json
URL แบบรีโมตหรือคำสั่งบนเครื่องของคุณ? การติดตั้งสองแบบต่างกันอย่างไร
รันบน PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
เปิดจากผู้เผยแพร่
Make any booking system bookable by AI agents through one integration.
Restaurants, salons, clinics: implement one BookingProvider interface, and OpenBooking exposes
it to agents over MCP, UCP and A2A. It enforces the rules that make agent bookings
safe:
Postgres storage for OpenBooking: bookings and holds, idempotency, Studio activity and connector records.
npx create-openbooking my-salon
cd my-salon && npm run dev
You get a booking backend with a booking page, a website snippet, Studio and an MCP endpoint.
Edit business.ts for staff, services and opening hours.
npm install @openbooking-sh/server @openbooking-sh/provider-memory
import { createOpenBookingApp, listen } from '@openbooking-sh/server';
import { createDemoSalonProvider } from '@openbooking-sh/provider-memory';
const { app } = createOpenBookingApp({
provider: createDemoSalonProvider(), // or your own BookingProvider
baseUrl: 'http://localhost:3000',
});
await listen(app, { port: 3000 });
// MCP at /mcp · booking page at /book · Studio at /studio · UCP at /.well-known/ucp
More: recipes (Postgres, Vercel, website snippet, your own booking system) · docs for AI coding tools · contributing
Requires Node 22.12+ and pnpm. The published packages run on Node 20+. Run corepack enable or npm i -g pnpm.
git clone <this repo> openbooking && cd openbooking
pnpm install
pnpm dev
This starts Studio Nord, a fictional hair salon (in-memory) with three stylists, three services (haircut, beard trim, color & cut with a deposit), opening hours and a cancellation policy. Run DEMO=restaurant pnpm dev for the restaurant demo instead.
MCP (Streamable HTTP) http://localhost:3000/mcp
UCP profile http://localhost:3000/.well-known/ucp
UCP REST http://localhost:3000/ucp/booking-sessions
A2A Agent Card http://localhost:3000/.well-known/agent-card.json
Studio (dashboard) http://localhost:3000/studio
Try it with an agent. Point any MCP client at http://localhost:3000/mcp. For example, run
npx @modelcontextprotocol/inspector. Then ask the agent to "book me a haircut with Maria on Friday
afternoon".
For stdio clients, use pnpm --dir examples/demo stdio (config snippet in
examples/demo/src/stdio.ts).
Try it with curl (UCP REST).
# 1. find a slot (EXTENSION: sh.openbooking.availability)
curl "localhost:3000/ucp/availability?date=2026-10-09&party_size=1&offering_id=haircut&time_from=15:00"
# 2. hold it (a UCP booking session); copy an offer id from step 1
curl -X POST localhost:3000/ucp/booking-sessions \
-H 'content-type: application/json' -H "Idempotency-Key: $(uuidgen)" \
-d '{"stays":[{"id":"<offer id>"}],"booker":{"first_name":"Ada","last_name":"Lovelace","email":"[email protected]"}}'
# 3. confirm, only with explicit user consent
curl -X POST localhost:3000/ucp/booking-sessions/<id>/complete \
-H 'content-type: application/json' -H "Idempotency-Key: $(uuidgen)" \
-d '{"user_confirmed":true}'
The demos are in-memory by default. Set DATABASE_URL and bookings, holds, idempotency records and Studio activity are stored in Postgres (tables are created on start):
DATABASE_URL=postgres://user:pass@localhost:5432/openbooking pnpm dev
On Vercel, add a Postgres database from the Marketplace (Neon, Supabase…) and use its pooled connection string. In code:
import { connectPostgres, migrate, postgresStores } from '@openbooking-sh/postgres';
const db = connectPostgres(process.env.DATABASE_URL!);
await migrate(db);
const stores = postgresStores(db);
createOpenBookingApp({
provider: createDemoSalonProvider({ store: stores.bookings }), // or new CalcomBookingProvider({ store: stores.calcom, ... })
serviceOptions: { idempotencyStore: stores.idempotency },
studio: { token: process.env.STUDIO_TOKEN, activity: stores.activity },
baseUrl,
});
Holds are reserved under a per-resource lock, so two servers can never hand out the same time.
The booking system for the people running the business, at /studio:
In local dev (baseUrl on localhost) the Studio opens without a login. Anywhere else, set a token: createOpenBookingApp({ ..., studio: { token: process.env.STUDIO_TOKEN } }). Without a token, the Studio API stays locked. Agent names are self-reported by clients, so use them for analytics only, never for access control.
pnpm dev:hosted
Businesses sign up at /signup and set up services, staff, hours and cancellation rules in Studio.
Each gets a booking page at /b/<id>. Every listed business is bookable through one MCP app at
/mcp (find_business → booking tools), with optional Google Calendar sync and confirmation
emails. See docs/HOSTED.md.
Design rules:
idempotency_key.{ code, message, suggested_next_action, retryable }.next_step, the instruction for the agent.serviceOptions.holdLimit to tune or disable it.search_availability
customer (on hold_slot or confirm_booking): first_name, last_name, and at least
one of email or phone_number (international format, e.g. +4791234567).
Slots and bookings:
start, end) are ISO 8601 with the venue's offset, e.g. 2026-10-13T10:00:00+02:00.expires_at is in UTC.{ amount: 45000, currency: "NOK" } is 450.00 NOK.resource says who or what is booked; also_available lists other staff free at that time.status is held, confirmed, cancelled or expired.Already on Cal.com or self-hosted Cal.diy? Your event types become bookable by AI agents with no code:
CAL_API_KEY=cal_live_... VENUE_NAME="Studio Nord" VENUE_TIMEZONE=Europe/Oslo pnpm dev
# optional: CAL_EVENT_TYPE_IDS="123,456" CAL_BASE_URL=https://cal.example.com VENUE_CURRENCY=NOK
Or in code:
import { CalcomBookingProvider } from '@openbooking-sh/provider-calcom';
const provider = new CalcomBookingProvider({
apiKey: process.env.CAL_API_KEY!,
venue: { id: 'studio-nord', name: 'Studio Nord', timezone: 'Europe/Oslo', currency: 'NOK' },
});
How it maps:
Limits in this beta:
BookingProviderYou own inventory and persistence. OpenBooking owns validation, idempotency, hold expiry, consent and cancellation rules.
import { BookingError, type BookingProvider } from '@openbooking-sh/core';
import { createOpenBookingApp, listen } from '@openbooking-sh/server';
class MySalonProvider implements BookingProvider {
info = { name: 'Studio Nord', description: 'Hair salon in Bergen' };
async listVenues() {
return [{ id: 'nord', name: 'Studio Nord', timezone: 'Europe/Oslo', currency: 'NOK' }];
}
async searchAvailability(query, ctx) {
// query: { venue_id, date, party_size, time_from?, time_to?, offering_id?, tags?, limit }
// Return Slot[]: each with an opaque slot_id, start/end (ISO with offset), price,
// deposit (or null) and a cancellation_policy computed for that slot.
}
async createHold({ slot_id, expires_at, customer, notes }, ctx) {
// ATOMICALLY reserve the slot until expires_at (transaction / unique constraint).
// If it's gone: throw new BookingError('slot_unavailable', 'Just taken.');
// Return the Booking with status 'held'.
}
async confirmHold({ booking_id, customer, payment_token }, ctx) {
// Re-check expiry atomically, charge the deposit if any, mark confirmed, return the Booking.
}
async getBooking(id, ctx) {
/* … */
}
async cancelBooking({ booking_id, reason, fee, refund }, ctx) {
// Release the hold, or cancel and record the fee/refund the engine computed.
}
// optional: updateBooking({ booking_id, customer?, notes? }, ctx)
}
const { app } = createOpenBookingApp({
provider: new MySalonProvider(),
baseUrl: 'https://book.studionord.example',
});
await listen(app, { port: 3000 });
The contract is documented in
packages/core/src/provider.ts.
provider-memory is a complete reference
implementation. The four rules:
BookingError with a specific code.Prove it with the conformance suite (vitest). It books slots until the provider says no, fires parallel holds, lets holds expire and cancels, and fails if any rule is broken:
import { describeProviderConformance } from '@openbooking-sh/conformance/vitest';
describeProviderConformance('MySystemProvider', {
create: () => new MySystemProvider(testConfig), // a fresh, empty provider per test
now: new Date('2030-06-03T08:00:00Z'), // before the date you search
query: { date: '2030-06-04', party_size: { total: 1 } }, // must return open slots
});
packages/
core/ Domain model, BookingProvider, BookingService (agent-safety rules)
provider-memory/ Configured provider (catalog + slot rules) + demo salon and restaurant
postgres/ Postgres storage: bookings, idempotency, Studio activity, Cal.com records
create-openbooking/ npx create-openbooking: a ready-to-run booking backend
adapter-mcp/ MCP tools (Streamable HTTP + stdio)
adapter-ucp/ UCP discovery + booking sessions (draft)
adapter-usp/ USP profile, catalog, availability, holds and bookings (draft)
adapter-a2a/ A2A Agent Card + SendMessage endpoint
studio/ OpenBooking Studio dashboard (/studio), incl. business settings
booking-page/ Public booking page: pre-filled links, JSON-LD, WebMCP, manage links, OpenAPI
client/ Typed fetch client for the booking page API
notifications/ Confirmation/cancellation emails with .ics invites
google-calendar/ Google Calendar sync (busy times, bookings as events)
server/ One Hono app mounting everything
hosted/ Many businesses on one deployment: sign-up, settings, the OpenBooking MCP app
examples/demo/
bench/ Agent-success benchmark (tasks + runner)
docs/ARCHITECTURE.md, docs/SPEC-NOTES.md, docs/HOSTED.md
pnpm dev # demo server with watch
pnpm test # vitest (unit + MCP end-to-end + bench smoke test)
pnpm typecheck
pnpm lint
pnpm build # tsup → dist/ per package
pnpm bench # run the agent benchmark (scripted baseline)
pnpm changeset # describe a change for release
The benchmark (bench/) runs booking tasks against isolated servers. It measures:
LLM drivers plug into a stub interface.
Postgres storage for OpenBooking: bookings and holds, idempotency, Studio activity and connector records.
{ "mcpServers": { "openbooking-sh-postgres": { "command": "npx", "args": [ "-y", "@openbooking-sh/[email protected]" ] } }}เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ระเบียนนี้ไม่ได้ระบุตัวแปรสภาพแวดล้อมที่จำเป็น
@openbooking Sh/postgres ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-10-28 Postgres storage for OpenBooking: bookings and holds, idempotency, Studio activity and connector records.