Jagantara

Jagantara is an AI agent powered cultural heritage explorer that connects family memories and historical evidence with personalized, playable media and cultural discoveries.

Comment

Inspiration

I built Jagantara from a simple question: how can someone explore the cultural history connected to a family place without turning memory, recommendation, or AI-generated text into a false claim about ancestry?

Family stories are meaningful, but they often combine documented events, remembered experiences, and imagined details. Most digital heritage tools blur those categories together. I wanted to create an experience that preserves the emotional value of a memory while making the origin of every claim visible.

I was also inspired by the possibility of using taste as a doorway into history. Music, books, films, and destinations can help someone engage with a place in a personal way. Qloo made it possible to create those connections across cultural domains without claiming that an affinity proves identity or genealogy.

What it does

Jagantara transforms a family place, an approximate period, an optional memory, and two or three cultural interests into an evidence-aware cultural journey.

The experience includes:

  • A historical timeline containing source-backed claims and direct links to supporting material.
  • Clearly attributed family memories that remain separate from historical evidence.
  • Explicitly labeled creative reconstructions that are never presented as fact.
  • A Qloo-generated cultural route across music, books, films, and destinations.
  • Explainability details showing which verified cultural signals contributed to a recommendation.
  • Playable, freely licensed Wikimedia Commons media for the curated sample journeys.
  • A visible agent trace showing which tools ran, succeeded, failed, or were skipped.

The central interaction is the Taste Swap. A visitor can switch between a rhythm-oriented profile and a page-and-screen profile. The historical timeline remains unchanged, while the Qloo signals and cultural discoveries change. This demonstrates that personal taste can open a different doorway into history without rewriting the history itself.

Jagantara includes four disclosed fictional samples covering Tahlequah and Cherokee history, Irish immigration in Five Points, Italian immigration in Little Italy, and African American history in Harlem or the user defines theirs to use Jagantara.

How I built it

I built Jagantara with Next.js 16, React 19, and TypeScript. Vinext and Vite compile the application into a Cloudflare Worker that can run through Cloudflare Sites or locally with Wrangler.

The React interface collects the visitor’s place, period, connection, memory, and cultural interests. It sends the normalized input to a server-only journey endpoint. Credentials and external-service calls never enter the browser.

I organized the server as a tool-oriented agent pipeline:

  1. The input validator normalizes text, enforces length limits, requires two or three interests, removes unsafe markup, and rejects attempts to infer ethnicity or genealogy from surnames.

  2. The historical branch either loads a curated sample packet or searches Wikimedia for relevant historical sources.

  3. When OpenRouter is configured, the model composes a timeline using supplied source excerpts. Every generated historical item must include an exact excerpt copied from its referenced source.

  1. The evidence checker validates source URLs, year consistency, and lexical support. Unsupported historical claims are removed.

  1. The Qloo branch classifies each interest as a named entity or cultural concept.
  2. Named entities are resolved through Qloo’s typed /search endpoint, while broader concepts use /v2/tags.

  1. Candidate signals are scored using normalized name overlap, expected entity type, confidence, and the margin over the next candidate. Weak or ambiguous matches are rejected.
  2. Verified Qloo entity and tag IDs are sent to four concurrent /v2/insights requests for music, books, films, and destinations.

  1. Successful categories are preserved even if another category fails.
  2. The accepted results are assembled into a JourneyResult containing the timeline, narrative, cultural discoveries, route, media, service state, and agent trace.

I added a bounded in-memory cache for Qloo GET responses, server-only secret handling, retry and timeout controls, explicit 401/403/429 states, and a 22-second end-to-end Qloo deadline.

I tested the implementation with Node’s test runner, TypeScript checks, ESLint, Playwright, and axe accessibility checks. The tests cover Qloo request contracts, entity ambiguity, tag resolution, partial category failures, credential errors, source entailment, taste-swap invariants, responsive behavior, and accessibility.

Challenges I ran into

One major challenge was preventing recommendations from being mistaken for historical evidence. Qloo provides cultural affinity, not proof of ancestry or personal preference. I addressed this by giving Qloo results their own evidence type and adding visible explanations and cautionary language throughout the interface.

Entity resolution was another difficult problem. A text search can return a result with a similar name but the wrong type, or several candidates with nearly identical scores. I built a resolver that checks lexical similarity, expected type, provider confidence, and runner-up distance before allowing an ID into the Insights request.

Historical generation also required strict boundaries. A source URL alone does not prove that a generated sentence is supported. I required the model to return an exact contiguous excerpt and added a second validation layer for token overlap and year consistency. If a claim fails, Jagantara removes it.

The Qloo API introduced operational challenges involving hackathon-specific authentication, endpoint shapes, rate limits, timeouts, and partially successful category requests. I created defensive parsers, bounded retries, explicit error states, and independent category handling so one failure does not erase useful results.

Playable media created a separate provenance challenge. I needed public URLs, creator attribution, and license information that could remain stable even when a model refined the description. I used a fixed Wikimedia Commons allowlist for the sample journeys and prevented the model from modifying URLs, creators, or licenses.

Finally, I had to balance emotional storytelling with privacy. Jagantara accepts memories and personal context, but it does not require names, accounts, or exact personal identifiers. Only the explicitly entered public cultural-interest strings are sent to Qloo; the visitor’s memory is not.

Accomplishments that I’m proud of

I am most proud that Jagantara treats provenance as part of the user experience rather than hiding it in technical metadata. A visitor can immediately see whether an item is documented history, attributed testimony, a Qloo connection, or an imaginative reconstruction.

I am also proud that Qloo is essential to the central interaction. The historical layer provides context, but Qloo creates the cross-domain cultural route and powers the Taste Swap. When Qloo is unavailable, Jagantara shows that limitation honestly instead of replacing the results with fabricated recommendations.

The Taste Swap preserves the timeline byte-for-byte while changing the verified Qloo signals and discoveries. That invariant is enforced in automated tests.

What I learned

I learned that trustworthy AI experiences require more than adding citations. The system must preserve the relationship between each claim, its source, its evidence category, and the process that produced it.

I also learned that rejecting uncertain results is often more valuable than returning a larger result set. An unresolved Qloo interest or an unsupported historical sentence should remain absent rather than appear authoritative.

The project reinforced the importance of keeping generative models inside narrow boundaries. OpenRouter helps compose evidence-linked text and refine media descriptions, but deterministic code controls URLs, licenses, source excerpts, evidence labels, and Qloo entity IDs.

I learned that partial failure is a normal system state. Treating categories independently, preserving successful results, and communicating service status creates a much stronger experience than an all-or-nothing pipeline.

Most importantly, I learned that cultural personalization can be respectful when taste is presented as a path for exploration rather than a conclusion about identity.

What’s next for Jagantara

My next step is to expand the historical retrieval layer beyond Wikipedia search into libraries, museums, government archives, oral-history collections, and regional cultural institutions.

I also plan to:

  • Add multilingual search and presentation.
  • Support more geographic regions and cultural contexts.
  • Improve entity disambiguation with richer Qloo metadata.
  • Add deeper recommendation comparisons across taste profiles.
  • Introduce more curated, freely licensed media collections.
  • Build source-quality scoring and stronger evidence evaluation.
  • Add observability for latency, category failures, and evidence rejection rates.
  • Create an optional, consent-based way to save or export a journey.
  • Add printable and shareable evidence reports.
  • Expand accessibility testing across assistive technologies.
  • Evaluate the system with historians, archivists, librarians, and community cultural organizations.

ROAD MAP

My long-term goal is for Jagantara to become a respectful research companion: a tool that helps people move from memory to evidence and from evidence to cultural discovery without confusing affinity, imagination, and ancestry all powered by Qloo API.

Share this project:

Updates

Submission history