MCP Servers and Agentic Commerce: How One Backend Powers Every AI Assistant

For most of the internet’s life, “using a service” meant you driving: you open an app, you tap through screens, you fill in a form. Agentic commerce flips that around. You state an intent — “find me a discounted Starbucks gift card and buy the ₹1,000 one” — and an AI assistant does the driving on your behalf.

That only works if the assistant can actually do things, not just talk about them. And the standard that lets it do things is the Model Context Protocol (MCP). This post explains what an MCP server is, why agentic commerce depends on it, how it works with a language model step by step, and — the part we find most exciting at Faydo — how a single MCP server can power ChatGPT, Claude, Claude Code, WhatsApp, and your own app all at once.

What is an MCP server?

A language model, on its own, is a brilliant conversationalist with no hands. It can reason and write, but it can’t check a live price, place an order, or read your account. It also has a knowledge cutoff, so anything recent or private is simply unknown to it.

An MCP server gives the model hands. It’s a small service that exposes a set of tools — named, well-described actions the model is allowed to invoke — over a common protocol. MCP is often described as “a USB-C port for AI”: one standard connector that any compatible assistant can plug into to reach your data and actions.

For a commerce business like Faydo — a marketplace for discounted gift cards — our MCP server exposes tools such as:

• list_brands — search the catalogue
• get_brand — a brand’s live discount, price table, and redemption steps
• start_purchase — create an order and return a UPI payment link
• complete_purchase — verify payment and deliver the gift card
• get_my_vouchers — the user’s purchased cards

Each tool has a description and a typed set of inputs. The model reads those descriptions and decides which to use.

Why agentic solutions need it

You could, in theory, wire an AI into your systems by hand — custom glue code for every model, every endpoint, every quirk. People did this, and it doesn’t scale. Every new assistant meant a new bespoke integration.

MCP replaces that with one contract. The value shows up in three ways:

• Actions, not just answers. Without tools, an assistant can only describe your service from stale training data — and, worse, confidently invent details it doesn’t have. With tools, it works from live truth and can complete real tasks.
• Build once, connect anywhere. A single MCP server is consumed by any MCP-capable client. Add ChatGPT today, Claude tomorrow, a new assistant next year — no rework.
• One place for the rules. Pricing, permissions, business logic, and safety checks all live in the server. Every client inherits them automatically, so behaviour stays consistent no matter where the customer is.

That last point is the quiet superpower. The MCP server becomes your commerce brain — and every channel is just a face on it.

How it actually works with an LLM: tool-calling

Here’s the part that feels like magic but is refreshingly mechanical. When you connect an MCP server, the assistant does this loop:

1. Discover. It asks the server, “what tools do you have?” and reads their descriptions.
2. Decide. When you ask a question, the model decides whether a tool would help, and with what inputs.
3. Call. The client invokes that tool on the MCP server.
4. Return. The server does the real work and returns a result.
5. Answer. The model folds that result into a natural reply — and may call more tools before it’s done.

A worked example. You type: “What’s the discount on Zomato?”

1. The model reads Faydo's tools and picks one:
     → get_brand(slug: "zomato")

2. Faydo's MCP server returns REAL data (not a guess):
     Zomato — 8% off
     Choose one amount:
       1. ₹500  → pay ₹460  (save ₹40)
       2. ₹1000 → pay ₹920  (save ₹80)
     🔗 faydo.in/brand/zomato

3. The model turns that into a reply:
     "Zomato gift cards are 8% off on Faydo right now — a ₹1,000 card
      costs ₹920, so you save ₹80. Want me to grab one?"

Notice what happened: the price came from us, not the model. This is the essential discipline of agentic commerce — the server hands the model facts, and the model’s job is to present them, never to invent them. (We wrote about that fight against hallucinated prices in a separate post.)

Now say you reply “yes, the ₹1,000 one.” The loop continues:

4. The model confirms the amount with you, then:
     → start_purchase(brand: "zomato", amount: 1000)

5. The server creates the order and returns a UPI link.
     The model shares it and asks you to pay.

6. After you pay, the model calls:
     → complete_purchase(orderId: ...)
   and the server verifies payment and delivers your card code + PIN.

Two tool calls, a confirmation, and a payment — a complete purchase, conducted entirely in conversation. Crucially, the server enforces the guardrails at every step: it validates that the amount is one the brand actually sells, and it never charges you without your explicit yes.

One server, every channel — including WhatsApp

This is where it gets powerful for a business. Because the commerce brain lives in the MCP server, the same server serves very different front doors:

  ChatGPT ─┐
  Claude   ─┤
  Claude   ─┤
  Code     ─┼──▶  Faydo MCP server  ──▶  Faydo backend
  Web/app  ─┤       (the commerce brain)     (catalogue, pricing, orders)
  assistant┘
  WhatsApp ─┘

There’s a neat distinction in who operates the client:

• ChatGPT, Claude, Claude Code, Cursor are MCP clients run by the end user. They connect directly to our server and sign the user in with a one-tap, keyless flow. Each user brings their own identity, so everyone is naturally kept separate.

• WhatsApp is different — we operate the client. WhatsApp has no built-in MCP support, so we run a lightweight gateway: it receives the user’s message, identifies them from their verified phone number, opens their own private session to the very same MCP server, runs the tool-calling loop, and replies — all in the WhatsApp thread. The user just chats; there’s nothing to install and no key to paste.

• Our own web and mobile assistant is yet another client of the same server, so it browses and buys using the identical tools and pricing.

The importance of this can’t be overstated. We did not build “gift cards for ChatGPT,” then “gift cards for WhatsApp,” then “gift cards for the app.” We built one commerce engine and gave it several mouths. A discount fixed once is fixed everywhere. A new safety check added once protects every channel. And when the next AI surface appears, Faydo is a connection away from working there too.

Meeting customers where they already are

Agentic commerce isn’t a far-off idea — people are already asking assistants to shop for them. The businesses that show up in those conversations will be the ones that exposed their capabilities as clean, trustworthy tools an AI can use.

That’s the whole bet behind Faydo’s MCP server: put our catalogue, our discounts, and a safe checkout behind one standard interface, and let customers reach it from ChatGPT, from Claude, from WhatsApp, or from our own app — whichever they happen to be typing in. One brain, many channels, the same honest price everywhere. That’s how FAYDO: pay less, every time follows you wherever you shop.