Synaptic

Synaptic is a idea exploration app. A user enters one idea, gets a graph of AI-generated directions, clicks into any node to inspect a structured dossier, runs cross-checks against external sources.

Comment

Synaptic is a full-stack idea exploration app. A user enters one seed idea and receives an interactive, zoomable thought graph of AI-generated directions — complete with expandable nodes, structured descriptions, cross-checks against the web, patents, GitHub, and custom data sources, and a one-click one-pager export.

Inspiration

Every great project starts with a problem, and ours started with a very relatable one: we had absolutely no idea what to build.

We spent more time than we care to admit staring at blank whiteboards, half-formed notes, and the blinking cursor of an empty document, trying to conjure up the idea. Existing tools were either too generic or too complicated. None of them helped you go from nothing to something worth exploring.

The irony was not lost on us. We were struggling to come up with an idea for a hackathon project about AI, while sitting next to some of the most powerful language models ever built. So we asked ourselves: what if we just built the thing we wished existed?

That question became Synaptic — an app that takes a single seed thought and grows it into a whole map of what it could become.

How We Built It

The Stack

We built Synaptic on a modern full-stack:

  • Next.js 16 + React 19 + TypeScript — the application framework and UI layer, styled with Tailwind CSS 4.
  • React Flow + D3 + Three.js — the graph renderer, supporting both a clean 2D circular layout and a fully interactive 3D mode with camera controls and zoom-aware labels.
  • OpenAI Responses API — the generative core, handling idea generation, node expansion, critique and tension analysis, and one-pager synthesis using structured JSON output.
  • Exa, Serper, GitHub Search, Elasticsearch, + Jina Reranker — the cross-check pipeline, fanning out across web and academic search, patents, open-source repositories, and custom data sources, then reranking all results for relevance.
  • Supabase — authentication (email/password, Google OAuth, email verification, password recovery), storing of ideas and edges, with per-user row-level security.

AI-Assisted Development

We also leaned heavily on AI tools during development itself, which felt appropriate given what we were building. We used three assistants across the project:

  • GitHub Copilot for in-editor autocomplete, boilerplate, and TypeScript type scaffolding.
  • OpenAI Codex for generating search pipeline logic and agent architecture scaffolding.
  • Claude (Anthropic) for architectural reasoning, documentation, and debugging complex API integrations.

What We Learned

The single biggest lesson from this project was how to orchestrate multiple external search APIs reliably.

It sounds straightforward — just call five APIs, merge the results, return the best ones. In practice, every provider has different response shapes, different score semantics, different failure modes, and different latency profiles. Exa returns highlight scores between 0 and 1. GitHub returns star counts with no relevance signal at all. Elasticsearch returns raw BM25 scores that need normalising before they can be compared to anything else. Patents return snippets with no scores whatsoever.

We built a normalisation layer that maps all of these into a unified PriorArtHit type with a consistent matchScore, deduplicated by URL, and then passed the top candidates through Jina's reranker to produce a final ordering that is actually meaningful.

Challenges

Wiring Together So Many APIs Reliably

Each of the five cross-check providers had to be treated as an independent, potentially unreliable process. If Serper was rate-limited, the patent results should gracefully return empty — not crash the whole cross-check. If Elasticsearch was not configured, it should silently skip with a log message. If Jina's reranker returned an unexpected response shape, we needed to fall back to our own similarity scoring rather than surface a broken UI to the user.

Getting that right took more iteration than any other part of the codebase.

What's Next

Synaptic turns a seed idea into a structured exploration. Where we want to take it next:

  • Collaborative sessions so teams can explore an idea together in real time.
  • Richer cross-check sourcing, including academic paper search via arXiv and Semantic Scholar.
  • Potentially integrating into other companies as a viable brainstorming/ideation tool.

The irony of building an idea-generation tool is that it keeps giving us more ideas for itself.

Built with Next.js, React, TypeScript, OpenAI, Supabase, Exa, Serper, Elasticsearch, Jina, D3, and Three.js. Code assisted by GitHub Copilot, OpenAI Codex, and Claude.

github.com/frank-shen-07/Synaptic

Built With

  • api-routes)-react-19-styling-tailwind-css-4-database-&-auth-supabase-?-postgresql-database
  • authentication
  • deployment:
  • export:
  • github-api-visualisation:-d3.js
  • jina-reranker-search-apis:-exa
  • jspdf
  • languages:-typescript
  • react-styling:-tailwind-css-database-&-auth:-supabase-ai:-openai-gpt-4o
  • serper-(google-patents)
  • server-components
  • session-analysis
  • session-persistence-ai-/-llm-openai-gpt-4o-?-idea-generation
  • sql-framework:-next.js
  • three.js
Share this project:

Updates