Resource Match

• 

• 

  home page

Inspiration

B2B procurement is still a guessing game. Buyers send RFQs into the void; suppliers burn cycles on leads that were never going to close. We took a page from Ditto-style pre-screening: run many realistic conversations before humans get on a call, so both sides only invest time in deals that already look viable.

Industrial sourcing made that idea concrete—valves, MOQs, lead times, certifications, and payment terms all have to align. Resource Matchmaker simulates those negotiations at scale so buyers see ranked suppliers backed by evidence, not just a keyword match.

What it does

Resource Matchmaker is an AI-orchestrated B2B matching platform for procurement teams and suppliers.

A buyer describes what they need in natural language (or submits a structured purchase request). The system then:

1. Intake — Parses the request into a hackathon-compliant purchase request schema, optionally grounded in live supplier catalog data.
2. Match — Filters and ranks suppliers on hard constraints (category, MOQ, capacity, lead time, budget) plus soft signals (price fit, delivery, quality, origin preferences).
3. Simulate — Runs multi-round buyer/supplier negotiations in parallel across top-K candidates, powered by Gemini agents with private negotiation context (budget ceilings, price floors, and style never leak into the public transcript).
4. Judge & rank — Scores each outcome, blends simulation signals into a hybrid ranking, and returns deal cards with explanations, concerns, and risk flags.
5. Human review — Buyers can annotate, approve, or renegotiate with feedback; the pipeline can spawn a child run that incorporates that input.

A Next.js dashboard covers registration, match runs, live status (including WebSocket updates), and history. MongoDB stores users, personas, catalogs, match runs, deals, and ADK session state. MongoDB MCP (read-only) lets developers and agents inspect the same data during build and debug.

How we built it

The negotiation loop is supplier → buyer → round score → critic feedback, with structured JSON outputs enforced through Pydantic schemas. Matching stays deterministic; the LLM handles language, bargaining, and post-deal evaluation.

Challenges we ran into

• Information asymmetry — Buyers’ budgets and suppliers’ floors must shape agent behavior but never appear in messages the other side sees. That required careful prompt design, session-state separation, and tests around private fields.
• Parallel simulations at hackathon scale — Running K suppliers × N simulation runs hits Gemini rate limits (429 / RESOURCE_EXHAUSTED). We added retries with backoff and orphan-run recovery when the API restarts mid-pipeline.
• Grounded intake — Turning free-text RFQs into valid purchase requests while respecting real SKU/catalog fields from Mongo was trickier than a pure NL→JSON prompt.
• Production plumbing — MongoDB Atlas TLS on Cloud Run (CA bundles, connection string secrets) and baking NEXT_PUBLIC_API_URL at client build time both caused “works locally, fails deployed” moments.
• Ranking that humans trust — Balancing deterministic match scores, per-deal agent scores, and simulation-derived signals without overfitting a single number took several iterations (SCORE_ALPHA / SCORE_BETA and hybrid weights).

Accomplishments that we're proud of

• Shipped an end-to-end match-run pipeline—not a single demo chat—from NL intake through ranked outcomes persisted in MongoDB.
• Built role-faithful agents with a private critic layer, so negotiations feel strategic rather than two identical chatbots talking past each other.
• Ingested a realistic supplier dataset (19 industrial merchants with full catalogs) and wired one-click demo auth for judges and teammates.
• Added human-in-the-loop review (note, approve, renegotiate with child runs) so AI recommendations stay accountable.
• Deployed a split Cloud Run architecture (UI + API + Atlas) and integrated MongoDB MCP for sponsor-compliant, read-only agent access to project data.
• Maintained a test suite (matching, human review, memory, token quota, agent mappers) so refactors during the hackathon did not break core contracts.

What we learned

• Orchestration beats monolithic prompts — ADK’s sequential/loop composition made it easier to add critic feedback and scoring steps without rewriting the whole agent.
• Structured output is non-negotiable for procurement—price, terms, and signals (COUNTER_OFFER / ACCEPT / REJECT / WALKAWAY) must be machine-checkable, not buried in prose.
• MongoDB is the system of record and the debug surface — the same collections power the API, the UI, and MCP-backed inspection during development.
• Simulation quality depends on profiles — negotiation style, priorities, and catalog shape matter as much as the LLM model choice.
• Humans still close deals — the best UX was ranking + explanation + an explicit review path, not fully autonomous auto-award.

What's next for Resource Matchmaker

• Calibrate close probability on real win/loss data instead of fixed simulation weights.
• Multi-supplier order splitting when buyer profiles allow splitting quantity across vendors.
• Deeper catalog intelligence — embeddings or semantic match beyond category/MOQ filters.
• Supplier-side insights — analytics on which SKUs win simulations and why deals stall.
• Stronger enterprise readiness — SSO, audit logs, regional data residency, and write-gated MCP only where operators explicitly allow it.
• Broader verticals — start from industrial valves/parts, extend templates to electronics, packaging, and services procurement.

Built With

• docker
• fastapi
• framer
• google-adk
• google-cloud-run
• google-gemini
• jwt
• mongodb
• mongodb-atlas
• mongodb-mcp-server
• next.js
• pydantic
• python
• react
• tailwind-css
• three.js
• typescript
• vertex-ai
• websockets