Echo

The open-source knowledge engine that connects, preserves, and evolves humanity’s collective learning.

Comment

Inspiration

I kept seeing how knowledge disappears so fast. A GitHub repo gets deleted, a blog post disappears, someone leaves a project, and years of learning vanish. It felt like humanity keeps losing its memory. I wanted to build something that could remember everything, connect ideas, and help people explore knowledge without starting from scratch every time. That’s how ECHO came to be.

What it does

ECHO is like a living map of knowledge. You put in a GitHub repo, blog post, or text, and it extracts the key ideas, methods, and connections. Then it builds a graph showing how everything links together. You can explore the graph, see how ideas evolved, and even add your own knowledge.

It’s not just storing info—it’s helping people understand relationships between ideas and learn faster.

How we built it

We started simple:

  • Backend: FastAPI
  • Frontend: React + D3.js
  • Graph construction: Jaccard similarity for edge weights

The Jaccard similarity between two nodes ( A ) and ( B ) is computed as:

[ J(A, B) = \frac{|A \cap B|}{|A \cup B|} ]

Edges are created only when ( J(A, B) > 0.1 ) to reduce noise.

We also use D3.js force-directed simulation for interactive visualization:

  • Repulsive force: ( F_{\text{repel}} = -200 \cdot (1 + \text{connectionCount} \cdot 0.5) )
  • Attractive force: ( F_{\text{link}} = 100 \cdot (1 - \text{weight}) )

For AI content analysis, we integrate Gemini API to extract structured knowledge like:

[ \text{Node} = {\text{key concepts, methods, related topics, insights}} ]

Nodes are stored in a JSON database (upgradeable to SQLite) and rendered interactively in the frontend.

Challenges we ran into

  • Messy AI outputs: Gemini sometimes returned malformed JSON; we had to handle parsing errors gracefully.
  • Graph readability: Large graphs could look chaotic; we tuned D3 forces for clarity.
  • Feature prioritization: Some advanced features had to be left unfinished so core functionality could shine.

Accomplishments that we're proud of

  • Automatic knowledge connections that are meaningful and navigable.
  • Interactive graph visualization for exploring linked ideas.
  • Robust handling of AI parsing errors.
  • Proof that a single developer can build a tool that scales learning for everyone.

What we learned

  • Building full-stack projects end-to-end is tough but rewarding.
  • AI outputs are powerful, but you must handle edge cases.
  • Graph algorithms like Jaccard similarity are simple yet effective.
  • Sometimes leaving features unfinished is better than a half-baked core.

What's next for ECHO

  • Add more sources beyond GitHub and text.
  • Improve AI summarization and cross-domain linking.
  • Introduce temporal and popularity weighting for edges.
  • Eventually build a living memory engine for the global developer and research community.

Built With

Share this project:

Updates