PokeMarket AI

Track Pokémon cards with our AI app! Powered by Gemini & MongoDB, log your collection and chat with a smart assistant to verify sets, rarities, and current market values instantly.

Comment

Inspiration

PokeMarket.ai was born out of a lifelong love for Pokémon and our own history as avid card collectors. Like millions of others, we grew up chasing holographic base-set cards, trading on school playgrounds, and opening booster packs with that unforgettable rush of excitement.

As adults returning to the hobby, we quickly realized that the modern Pokémon Trading Card Game (TCG) market had evolved into a complex, fast-moving financial landscape. Tracking a growing collection had become an absolute chore—forcing collectors to constantly jump between clunky manual spreadsheets, static database catalogs, and third-party market aggregators just to calculate their portfolio's value.

We built PokeMarket.ai to bring the fun back to collecting. Driven by our own frustrations and passion, we set out to build a seamless, unified solution: a conversational AI companion that acts as an intelligent data layer over your personal inventory. Instead of clicking buttons and filtering massive data tables, collectors can simply talk to the app like a knowledgeable friend—logging their collection, verifying rarities, and tracking market performance through natural, intuitive conversation.

What it does

PokeMarket.ai is a conversational AI companion that turns tracking a Pokémon card collection from a chore into a seamless experience. Instead of clicking through clunky spreadsheets or filtering massive data tables, collectors can simply talk to the app like a knowledgeable friend. Driven by a gemini-2.5-flash engine, users can instantly log their personal physical inventory, check exact card variations, verify rarities, display markdown card art visuals, and pull live market valuations dynamically through natural, intuitive conversation.

How we built it

We engineered a high-throughput, modular backend container deployed entirely on serverless Google Cloud Run infrastructure:

Orchestration: Built using Python and the Google Agent Development Kit (ADK) to drive the AI agent.

The Data Layer: Set up a read-only catalogue database of over 23,000 official cards, alongside user transaction records, hosted on MongoDB Atlas.

Dynamic Tools (MCP): Rather than writing standard, rigid API wrappers, the Python runtime dynamically boots an open-source Node.js Model Context Protocol (MCP) server (mongodb-mcp-server) as an internal sub-process. This allows Gemini to autonomously inspect schemas and query the database.

The Valuation Engine: Real-time asset pricing metrics are integrated directly from the PokéTrace API using custom Python service utilities.

Challenges we ran into

  1. Evading the 429 Quota Wall for Free: Operating strictly within a non-billable Google Cloud free trial meant dealing with tight rate limits. Massive JSON files from database tools were flooding the model, causing 429 RESOURCE_EXHAUSTED errors. We resolved this by injecting strict data-diet constraints into the agent's instructions, forcing Gemini to dynamically use precise projection matrices: data weight reduction = 1 - Size({id,name,set,image})/Size(Raw full JSON) This cut token weight by roughly 90%, preserving free tier limits while keeping vital card image strings intact.

  2. Overcoming 504 Timeout Bottlenecks: Valuing large portfolios meant sequential network handshakes were lagging and triggering 504 gateway timeouts. We built an optimised batch routine (get_prices_batch) leveraging Python's ThreadPoolExecutor to multi-thread concurrent requests, safely flattening execution latency to: Latency ≈ max(t_1, t_2, ..., t_n) + ε

  3. Pydantic Validation Crashes: The Node.js MCP server generated comprehensive parameter schemas that violated the strict Pydantic requirements of the Google ADK framework, causing boot failures. We deployed a runtime defensive monkey-patch over the ADK's internal _gemini_schema_util module to programmatically intercept and sanitise tool dictionaries on the fly.

Accomplishments that we're proud of

We are incredibly proud of building a sophisticated, dual-runtime application (Node.js running concurrently inside a Python container) that operates entirely within Google's serverless free tiers without breaking or crashing. We successfully bridged childhood passion with complex, modern system architecture—creating an interface where complex database projection parameters, multi-threaded API requests, and advanced schema filters happen completely out of sight, leaving the collector with a clean, magic-like user experience.

What we learned

This project provided hands-on experience in building production-grade, autonomous LLM workflows rather than simple prompt wrappers. We mastered configuring the Model Context Protocol (MCP) to securely decouple AI layers from database states, handling asynchronous thread pools in Python web environments, and designing rigid system instructions to programmatically regulate resource utilization at the model level.

What's next for PokeMarket AI

The next step for PokeMarket.ai is expanding from a text-based inventory tool into full computer vision collection management. We plan to integrate Gemini’s native multimodal capabilities so collectors can upload a single real-time photo of a physical card or a binder page. The agent will then visually analyze the card's exact print variant, assess its physical condition (e.g., identifying corner wear or surface scratches), cross-reference it with the database, and catalog it instantly without the user typing a single word.

Built With

Share this project:

Updates