MCIP's decision-making capabilities start with intelligent product discovery — choosing the right search mode, interpreting relevance scores, and leveraging the LangGraph agentic pipeline's automatic filter extraction. Today, agents can make smart choices between simple vector search and the 4-stage agentic workflow. As the Machine Customer protocol evolves, decision making will extend to multi-store comparison, cart optimization, and preference learning.
Imagine you're helping a friend shop for a laptop. You don't just list every laptop in existence — you consider their needs, compare options, filter out inappropriate choices, and present results with confidence. That's what MCIP enables AI agents to do, starting with intelligent product discovery.
MCIP is a Machine Customer protocol — a universal standard for how AI agents interact with commerce. Product discovery is the first module, and it's where decision-making begins. When a user says "Nike shoes under $100," the agent faces real choices: Should I use fast vector search or the full agentic pipeline? How do I interpret the scores? What do the extracted filters tell me about what happened?
These aren't hypothetical questions. They're decisions MCIP helps agents make right now through its two search modes, rich response metadata, and the LangGraph agentic workflow.
This is the first and most important decision an AI agent makes with MCIP. The protocol provides two complementary search endpoints, each suited to different situations.
GET /search?q=laptop&take=10Direct vector similarity search in Qdrant. No LLM calls — pure embedding-based matching. This is your fast path.
When to use it:
What you get: Results ranked by cosine similarity score (0–1), with filteringStatus: "VECTOR_ONLY" in the response metadata.
GET /hard-filtering/search?q=nike+shoes+under+100&take=10The full 4-stage LangGraph workflow. This is MCIP's core intelligence layer.
When to use it:
What you get: Results filtered by extracted brand/category/price, verified by LLM, with filteringStatus: "AI_FILTERED" and detailed appliedFilters metadata.
Think of it like asking for directions. Sometimes you just need a general heading (vector search). Other times you need turn-by-turn navigation that accounts for traffic, road closures, and your preference for scenic routes (agentic search). A smart agent picks the right mode for each query.
Here's a practical approach agents can use:
if query contains price words ("under", "between", "cheap", "expensive")
OR query contains brand names
OR query contains exclusions ("except", "not", "but not")
OR query contains category qualifiers ("gaming", "professional", "kids")
→ Use agentic search (/hard-filtering/search)
else
→ Use simple vector search (/search)When in doubt, the agentic endpoint handles simple queries gracefully too — it just won't extract any filters, effectively falling back to vector search with an LLM verification pass.
Every search result includes a score field (0–1) representing cosine similarity between the query embedding and the product embedding. These scores aren't just numbers — they're confidence indicators that should shape how agents present options.
Think of it like a restaurant sommelier recommending wine. The perfect pairing (0.90+) gets enthusiastic endorsement. A good option (0.75) receives a measured recommendation. An adequate choice (0.50) might be mentioned as "if you're open to alternatives."
{
"title": "Nike Air Max 90",
"score": 0.892,
"price": { "amount": 89.99, "currency": "USD" },
"brand": "Nike"
}AI agents should translate scores into natural language that reflects confidence. Instead of "This product has a relevance score of 0.89," say "This looks like exactly what you're looking for!" Instead of "Score: 0.45," try "This might work, though it's not quite what you described."
Smart agents establish score thresholds that trigger different behaviors:
Above 0.85 — Strong match. Present immediately with a confident recommendation. These are products that closely match the query's semantic meaning. Like finding exactly the book someone described.
0.70–0.85 — Good match. Include in results with positive framing. These meet most requirements. Like finding a restaurant that has most of your favorite dishes.
0.50–0.70 — Partial match. Show as alternatives with "you might also consider" framing. Useful when the top results are sparse.
0.30–0.50 — Weak match. Only show if nothing better exists, with clear caveat about relevance.
Below 0.30 — Noise. Generally discard. These are semantically distant from the query.
Scores mean slightly different things depending on the search mode:
filteringStatus: "VECTOR_ONLY"): Scores reflect pure semantic similarity. A 0.80 means the product description is semantically close to the query text.filteringStatus: "AI_FILTERED"): Scores reflect similarity within the filtered set. Results have already passed brand, category, and price filters — so even a 0.65 score represents a product that meets the hard constraints and is a reasonable semantic match.This distinction matters. A 0.70 in an AI-filtered result set may be a better recommendation than a 0.85 in an unfiltered set, because the filtered result already satisfies the user's explicit requirements.
The agentic search response includes rich metadata that helps agents make presentation decisions. This is unique to MCIP — the protocol doesn't just give you results, it tells you how it arrived at them.
| Status | Meaning | Agent Action |
|---|---|---|
AI_FILTERED | LangGraph extracted and applied filters (brand, price, category) | Show applied filters to user, high confidence in relevance |
VECTOR_ONLY | Pure vector similarity, no filters extracted | Results are broad — agent may want to suggest refinements |
FALLBACK | Degraded mode (e.g., embedding API failure) | Warn user that results may be less precise |
When filteringStatus is AI_FILTERED, the response includes what was extracted:
{
"appliedFilters": {
"brand": ["Nike"],
"priceRange": {
"min": null,
"max": 100,
"currency": "UAH"
}
}
}Agents should use this metadata to give users transparency: "I searched for Nike shoes under $100. Here's what I found." This builds trust — users know the agent understood their intent, and they can see exactly what constraints were applied.
If appliedFilters is empty but filteringStatus is AI_FILTERED, the LangGraph pipeline ran but couldn't extract meaningful filters from the query. The agent should treat these results like vector-only search.
The 4-stage LangGraph workflow makes several intelligent filtering decisions automatically. Understanding these helps agents present results with appropriate context.
Three GPT-4o-mini calls run in parallel to extract:
brand: ["Nike"])category: ["Gaming"])priceMax: 100)Each extraction uses Zod schemas for type-safe structured output. This means the filters are always well-formed — no parsing errors, no ambiguous values.
This is where MCIP makes a critical decision. Extracted brands are validated against the actual store catalog using Qdrant's facet search (getFacetValues("brand")).
If a user asks for "Rolex watches" but the store doesn't carry Rolex, the pipeline returns empty results immediately rather than showing irrelevant alternatives. This is an intentional design choice — it's better to clearly say "we don't carry that brand" than to show random watches and hope the user doesn't notice.
Agents should handle this case explicitly: "The store doesn't carry Rolex. Would you like me to search for similar luxury watches instead?"
Qdrant combines vector similarity with exact payload filtering in a single query. This means:
This is fundamentally different from filtering after search. It's like asking a librarian for "science fiction books on that shelf" rather than getting all books, then filtering by genre, then checking the shelf.
The final stage passes candidate results through GPT-4o-mini for semantic verification. This catches edge cases that vector similarity and payload filtering miss — products that technically match the filters but don't actually fit the user's intent.
For example, a search for "running shoes" might return hiking boots (semantically adjacent, correct category) — the LLM verification step can catch this and remove irrelevant results.
When the agentic pipeline returns few or no results, agents can implement progressive relaxation:
First: Use the agentic endpoint with the full query as-is.
Second: If results are sparse, try the simple vector search endpoint to get broader results without hard filters.
Third: Modify the query to remove the most restrictive constraint (usually price) and retry the agentic endpoint.
It's like grocery shopping with a specific list, then adapting when items aren't available. You wanted organic strawberries, but regular strawberries are better than no strawberries at all.
Before every search, decide: vector or agentic? This single decision dramatically affects result quality. Parse the user's query for signals — price words, brand names, exclusions, category qualifiers — and route accordingly.
Act like a knowledgeable friend, not a database. When scores are high and filters are applied (AI_FILTERED), make confident recommendations. When scores are moderate or results are unfiltered, be transparent: "Here are some options, though none is a perfect match."
Use the appliedFilters metadata to show your work. "I found 5 Nike shoes under $100" is more trustworthy than "here are some results." Users trust agents that explain their reasoning.
When the agentic pipeline returns FALLBACK status, don't pretend nothing happened. Tell the user: "I'm getting broader results than usual — you might need to filter these yourself." Honesty about limitations builds more trust than silent degradation.
Product discovery is the first module in the Machine Customer Interaction Protocol. As MCIP evolves, decision-making capabilities will expand across the full commerce lifecycle.
When MCIP supports multiple platform adapters, agents will face comparison decisions across stores. The same product at different stores means weighing price, shipping, availability, and trust. The protocol will provide unified results with source metadata so agents can make these trade-offs intelligently.
Cart tools (add_to_cart, view_cart, update_cart_item, clear_cart) will enable agents to manage purchase intent. Smart cart decisions include duplicate prevention, budget monitoring, and bundle recognition. Each cart operation becomes a decision point in the shopping conversation.
Over time, agents will learn user preferences from interaction patterns. Explicit signals ("I prefer Sony") and implicit patterns (consistently choosing eco-friendly options) will influence future search and presentation — boosting relevant results without hiding alternatives.