In simple terms: MCIP is a universal protocol for AI-powered commerce. It stands for Machine Customer Interaction Protocol — because AI agents aren't just tools that search for products. They're becoming machine customers: autonomous agents that can discover, compare, and transact on behalf of humans.
Think of MCIP as a USB standard for e-commerce. Before USB, every device needed its own special cable. USB changed everything — one port, infinite devices. MCIP does the same for AI-to-commerce interactions: one protocol that works with any store, for any commerce operation.
The Machine Customer Interaction Protocol is a universal commerce enablement system that gives AI agents a single, standardized interface for interacting with any e-commerce platform. It's not another marketplace or e-commerce platform — it's a translation and intelligence layer that sits between AI agents and the stores they interact with.
MCIP is designed around a modular architecture where each commerce operation (search, cart, checkout, orders) is a separate module plugging into the same three-layer framework. Intelligent product discovery is the first implemented module — and it's a powerful one. Using LangGraph-based agentic workflows, hybrid vector search in Qdrant, and OpenAI embeddings, MCIP transforms AI agents from keyword-matching bots into semantic search engines that understand shopping intent.
Cart management, checkout flows, and order tracking are designed to plug into the same architecture as it evolves into a full commerce lifecycle protocol.
We're entering an era where AI agents don't just assist with shopping — they do the shopping. An AI agent booking supplies for an office, comparing insurance quotes, or restocking inventory is acting as a machine customer. These agents need:
MCIP provides all of this. The name says it all: Machine Customer Interaction Protocol.
Today's e-commerce landscape is like a city where every store speaks a different language. Shopify speaks REST. WooCommerce speaks a different dialect of REST. Enterprise systems speak SOAP. Modern platforms speak GraphQL. Each has its own way of describing products, handling searches, and structuring data.
For AI Agents, this means:
For Businesses, this means:
For End Users, this means:
But fragmentation is only half the problem. Even when AI agents can connect to a store, they're stuck with keyword matching from the 1990s. When a user says "I need something cozy for movie night," traditional search looks for products with the word "cozy" — missing blankets described as "soft," hoodies listed as "comfortable," or snacks that create the perfect movie atmosphere.
AI agents think in concepts, not keywords. They understand context, intent, and relationships. But e-commerce platforms still treat them like text-matching robots.
AI agents operate at machine speed. They can't wait for:
When an AI agent needs to find a product, it needs results in milliseconds, not seconds. When it's helping a user make a decision, latency kills the experience.
MCIP solves these problems with a simple approach: instead of forcing AI agents to speak every store's language, we created a universal protocol that translates for all of them.
AI agents connect to MCIP via MCP (Model Context Protocol) — the emerging standard for AI agent tool communication — or through a simple REST API. Either way, they get a single, consistent interface that works identically regardless of which store is on the other end.
MCIP doesn't just connect — it understands. Using RAG (Retrieval-Augmented Generation) powered by OpenAI embeddings, MCIP translates human intent into product matches.
When someone asks their AI for "eco-friendly options for my home office," MCIP understands they might want:
This isn't keyword matching — it's true semantic comprehension of need, context, and intent.
MCIP provides two complementary search modes, each optimized for different scenarios:
1. Simple Vector Search (GET /search)
Direct vector similarity search in Qdrant. Fast, low-latency for straightforward queries. No LLM calls — pure embedding plus vector search. Best for simple, direct queries like "red running shoes" or "laptop stand."
2. Agentic Hard-Filtered Search (GET /hard-filtering/search)
The full LangGraph workflow — a 4-stage pipeline that extracts filters from natural language, validates brands against your catalog, performs hybrid search, and verifies results with an LLM. Best for complex queries like "Nike shoes under $100 but not running shoes."
Both return the same normalized response format, so your AI agent can use either (or both) without changing how it handles results.
MCIP stores products as semantic vectors in Qdrant, a high-performance vector database. Each product is converted into a 1536-dimensional embedding that captures its meaning, not just its words.
When you search, MCIP:
This hybrid search — combining vector similarity with exact payload filtering — is what makes MCIP results both semantically relevant and precisely filtered. All in 300–500ms.
MCIP's three-layer architecture is best understood through a familiar setting: a fine restaurant.
This is where AI agents place their orders. Like skilled waiters, our interface layer:
AI agents only need to learn one "menu" — whether they connect via MCP or REST, the experience is the same.
This is where the magic happens. Like a master chef's kitchen with multiple stations, our service layer has specialized services:
These are our connections to the outside world. Like reliable suppliers, our infrastructure layer:
text-embedding-3-smallCurrent Implementation: MCIP ships with a Vendure adapter (GraphQL) and a CustomAI mapper (GPT-4 powered fallback for any data format). Additional adapters for Shopify and WooCommerce are planned.
The agentic hard-filtered search is MCIP's standout feature — a 4-stage LangGraph state machine that transforms natural language into precise, filtered results:
Three LLM calls run simultaneously via LangGraph parallel execution:
All using GPT-4o-mini with Zod schemas for type-safe structured output parsing.
MCIP queries Qdrant's facet search for all available brands in the catalog. Extracted brands are validated against actual store inventory. If the requested brand doesn't exist in the store, MCIP returns empty results immediately — saving time and avoiding irrelevant matches.
A 1536-dimensional query embedding is generated via OpenAI, then Qdrant performs a hybrid search combining:
This combination ensures results are both semantically relevant and precisely filtered.
Search results pass through GPT-4o-mini for semantic verification. The LLM confirms results actually match the user's intent, filtering out false positives and returning the top verified products with metadata.
When an AI agent searches for "affordable running shoes for beginners," here's what happens in under 500ms:
The AI agent never sees the complexity — just relevant results, every time.
Stop writing integration code. Start building intelligence. With MCIP, your AI agents gain instant semantic search through MCP tools or a simple REST API.
Your future customers include AI agents — machine customers. MCIP makes your store AI-searchable without changing a single line of your existing API. Create an adapter once, and every AI agent can find your products through MCP or REST.
Finally, AI assistants that actually understand shopping requests. Your AI can:
MCIP is more than a search engine — it's a protocol for the full commerce lifecycle. Product discovery is the first module, with more on the way.
The first module is live and production-ready:
Expanding to true cross-platform machine customer capabilities:
Deeper AI-driven commerce capabilities:
Completing the Machine Customer protocol:
Ready to give your AI agent machine customer capabilities? You're just 5 minutes away:
MCIP is built on production-ready technologies:
| Component | Technology | Purpose |
|---|---|---|
| Framework | NestJS 11.x | Application structure, DI container |
| Protocol | MCP via @rekog/mcp-nest | AI agent tool communication |
| LLM Orchestration | LangGraph 1.0.x | Agentic workflow state machines |
| LLM Framework | LangChain 1.1.x | LLM abstractions, structured output |
| LLM Provider | OpenAI GPT-4o-mini | Filter extraction and verification |
| Embeddings | OpenAI text-embedding-3-small | 1536-dimensional vectors |
| Vector Database | Qdrant | Hybrid search + payload filtering |
| Queue System | BullMQ + Redis | Async product ingestion |
| Validation | Zod 3.x | Type-safe schema validation |
| Language | TypeScript 5.7.x | Type safety and developer experience |
"Is this just another API aggregator?"
No. MCIP is a Machine Customer protocol with semantic intelligence. We don't just forward API calls — we understand intent through agentic LangGraph workflows, convert queries to embeddings, extract filters via LLM, validate brands against your catalog, and return results ranked by meaning, not keywords.
"How do AI agents connect to MCIP?"
Two ways: through MCP (Model Context Protocol) tools — the standard for AI agent communication — or through a simple REST API. MCP gives agents like Claude and ChatGPT native tool access. REST works for any HTTP client.
"Do stores need to integrate with MCIP?"
No. MCIP connects to existing APIs through adapters (mappers). You create an adapter that transforms your store's data into MCIP's unified schema. We ship with a Vendure adapter and an AI-powered fallback mapper that handles any data format.
"What about transactions and payments?"
MCIP currently focuses on product discovery — the first module of the Machine Customer protocol. Cart management, checkout, and order tracking modules are on the roadmap. Today, MCIP helps AI agents find the right products; the purchase happens through existing store channels.
"What's the difference between the two search modes?"
Simple vector search (/search) is fast and direct — pure embedding similarity, no LLM calls. Agentic search (/hard-filtering/search) runs the full 4-stage LangGraph pipeline: parallel filter extraction, brand validation, hybrid search, and LLM verification. Use simple search for speed, agentic search for precision with complex queries.
"How is this different from regular search?"
Traditional search matches keywords. MCIP understands meaning through hybrid vector search and agentic intelligence. Search for "affordable laptop for college" and MCIP finds budget-friendly laptops good for students — even if those exact words aren't in the product description. The agentic pipeline can even extract implicit filters and validate them against your catalog.