Cortex

3d graph produced from ai convos

About the project

Most AI chat apps trap your thinking inside isolated conversations.

You ask one thing about transformers, another about food, another about startup ideas, and a week later all of it is buried in separate chat threads. The knowledge is there, but the shape of your thinking is invisible.

That was the inspiration for our project: what if AI conversations didn’t live as a list, but as a living map?

We built Cortex, a conversational knowledge graph that turns your chats into connected nodes, clusters, and paths. Instead of interacting with an LLM through disconnected chat windows, you can explore your ideas spatially. A topic like “USA” can become a central node, with connected ideas branching outward; imported conversations from ChatGPT, Claude, or Gemini can be transformed into a larger graph of what you’ve been exploring over time.

What it does

Cortex lets users:

start a new AI conversation from a graph-native interface
automatically extract concepts from prompts and AI responses
turn those concepts into nodes and edges in a persistent graph
connect related ideas across multiple conversations
import exported conversations from major AI platforms
distinguish between user-created nodes and speculative/ghost nodes
explore clusters visually instead of losing context in linear chat logs

The key idea is simple: your conversations should accumulate into a navigable memory system, not disappear into a scrollback buffer.

How we built it

We built the app with Next.js, React, and TypeScript.

On the frontend, we used a canvas-based graph view backed by D3 for layout and interaction, with Framer Motion for interface transitions and polish. We used Zustand for state management and persistence.

On the AI side, we used the OpenAI API in two steps:

generate chat responses
extract structured concepts and embeddings from the conversation

Those concepts are then converted into graph nodes and linked with a mix of:

semantic similarity from embeddings
keyword overlap
title-to-title / title-to-keyword relationship checks
conversation-level anchoring logic

We also built an import pipeline that can parse conversation exports from ChatGPT, Claude, and Gemini, including more flexible JSON and transcript-style formats.

Challenges we ran into

One of the biggest challenges was making the graph feel meaningful instead of fake.

It’s easy to generate nodes. It’s much harder to generate links that actually make sense. We ran into cases where obviously related concepts would end up disconnected, and other cases where inferred nodes floated around as useless clutter. We had to improve the graph logic so related concepts stayed anchored, primary conversation nodes remained visible, and speculative nodes could be toggled separately.

Another challenge was persistence and scale. Because graphs, conversations, and embeddings can get large quickly, browser storage limits became a real issue. We had to compact persisted state and make storage failure graceful instead of letting the app break under quota pressure.

Importing conversations was also trickier than expected because different AI platforms export data in very different shapes. We ended up building a more tolerant import parser rather than assuming one clean standard.

What we learned

We learned that the hard part of AI products is rarely just “call the model.”

The real work is in:

structuring messy LLM output into usable product state
designing graph logic that feels intuitive
deciding what should be persistent, visible, inferred, or hidden
making AI-generated interfaces feel trustworthy

We also learned how quickly spatial UI changes the feeling of interacting with an LLM. Once ideas become visible as a map, conversations feel less disposable and more cumulative.