Recall

Inspiration Every researcher knows this pain: you read 30 papers in a week, synthesize insights, have a breakthrough realization — then close your chat window. Gone. Next week, you're searching through browser tabs trying to remember which paper had that key insight about attention mechanisms.

I realized that current AI assistants are like goldfish — brilliant in the moment, but they forget everything the moment you close the tab. Researchers don't need another chatbot. They need a thinking partner that accumulates knowledge over time.

The question that drove me: What if AI could remember like a human researcher does?

Not just storing files, but understanding connections. Not just retrieving text, but synthesizing insights across documents. Not just answering questions, but building a knowledge graph that grows with every paper you read.

What I Learned Technical Insights Qwen Cloud's concept extraction is remarkably accurate. When I paste a research paper abstract, it identifies 5-7 key concepts with ~95% relevance. The model understands domain-specific terminology out of the box.

Knowledge graphs change how you think about memory. Once I visualized concepts as connected nodes, I started seeing patterns I never noticed before. The graph becomes a thinking tool, not just storage.

SQLite is underrated for AI applications. No setup, no server, instant queries. For a single-user research assistant, it's perfect. The entire database is one file that travels with your project.

OpenAI-compatible APIs are powerful. Using the same SDK for Qwen as I would for OpenAI meant I could build the entire backend in under 200 lines of Python.

Design Lessons Auto-extraction > manual tagging. Nobody wants to tag their notes. Let the AI do it. Visual feedback matters. The knowledge graph isn't just functional — it's the "wow" moment in demos. Synthesis > retrieval. Finding relevant text is table stakes. Combining multiple sources into a coherent answer is the real value. How I Built It Architecture (The 3-Layer Stack) ┌─────────────────────────────────────────────┐ │ Layer 1: User Interface │ │ Tailwind CSS + vis.js graph visualization │ └─────────────────┬───────────────────────────┘ │ REST API ┌─────────────────▼───────────────────────────┐ │ Layer 2: Flask Backend │ │ Python 3.14, ~200 lines │ │ • Memory CRUD operations │ │ • Concept extraction orchestration │ │ • Query synthesis pipeline │ └─────────────────┬───────────────────────────┘ │ ┌─────────────────▼───────────────────────────┐ │ Layer 3: AI + Storage │ │ Qwen Cloud API + SQLite │ │ • Concept extraction │ │ • Summarization │ │ • Multi-source synthesis │ │ • Persistent knowledge graph │ └─────────────────────────────────────────────┘ The Core Innovation: Memory Pipeline When you store content, Recall runs a 4-step pipeline:

Extract: Qwen identifies key concepts (e.g., "transformers", "self-attention", "encoder-decoder") Summarize: Generates a 1-2 sentence summary Link: Creates edges between concepts in the knowledge graph Store: Saves everything to SQLite with timestamps and access counts When you query, it runs a different pipeline:

Search: Find memories matching the query Rank: Sort by relevance and recency Synthesize: Qwen combines the top results into a coherent answer Cite: Include source attributions Key Code Decisions Why SQLite over PostgreSQL? Portability. The entire app — code + database — fits in a zip file. Judges can run it locally with zero configuration.

Why NetworkX over Neo4j? Simplicity. NetworkX is pure Python, no server needed. For a hackathon prototype, it's 10x faster to build with.

Why Flask over FastAPI? Familiarity and ecosystem. Flask has more tutorials, more Stack Overflow answers, and it's more than fast enough for this use case.

Challenges I Faced Challenge 1: Concept Extraction Quality Problem: Initial attempts with a generic prompt produced vague concepts like "technology" and "research."

Solution: I engineered a specific prompt that forces Qwen to extract domain-specific terms:

Extract 3-7 key concepts from this text. Focus on:

• Technical terms specific to this field
• Named methods or architectures
  
• Key quantities or measurements Return ONLY a JSON array of strings. This improved concept relevance from ~60% to ~95%.

Challenge 2: Knowledge Graph Clutter Problem: After storing 20+ papers, the graph became an unreadable mess of overlapping nodes.

Solution: Three fixes:

Size nodes by memory count — important concepts are bigger Color-code by type — papers are purple, concepts are blue Physics stabilization — vis.js auto-arranges nodes cleanly Challenge 3: Synthesis Quality Problem: Early synthesis answers were just concatenating summaries, not actually reasoning across them.

Solution: I added a "relevance ranking" step before synthesis. Only the top 8 most relevant memories are sent to Qwen, preventing information overload. The prompt explicitly asks for cross-referencing:

"Combine information from multiple sources. Do not just repeat individual summaries."

Challenge 4: The "Cold Start" Problem Problem: The app feels empty when you first open it. No memories = no value.

Solution: I added:

Bulk import — paste multiple papers at once Sample data — pre-loaded with 3 classic ML papers Quick-start guide — tells users exactly what to try first What's Next If I continue building Recall:

Chrome Extension — one-click paper saving from arXiv, Google Scholar, etc. PDF Parser — upload PDFs directly instead of copy-pasting Multi-user Support — share knowledge graphs with research teams Citation Graph — track which papers cite which, building a meta-knowledge graph Smart Reminders — "You stored this paper 3 months ago but haven't referenced it. Here's a summary."

Built With

• html
• python