Crowscap

Inspiration

Crowscap came from a simple but painful pattern: I kept saving useful things everywhere, in chats, links, videos, PDFs, screenshots, and notes, but most of them never became real knowledge.

They became a graveyard.

The deeper problem was not just forgetting. It was that I could understand something clearly today and still lose the details later as a result of access to vast information today. I could recognize an idea because I had seen it many times, but that did not mean I understood it well enough to use it. I could also save advice without knowing whether it was factual, opinion-based, weakly sourced, outdated, or only true in a specific context.

That became the thesis:

Most tools help people store information. Crowscap helps saved information become memory you can question, recall, and use.

What it does

Crowscap is a conversational memory intelligence system.

Users can paste a thought, article, YouTube link, PDF, or normal conversation fragment, and Crowscap turns it into structured, source-aware memory. It extracts atomic ideas such as claims, principles, warnings, actions, definitions, and questions, then stores them with source context, confidence, and embeddings.

Crowscap can:

• Capture text, URLs, YouTube transcripts, and PDFs.
• Preserve the original source beside extracted memories.
• Search memories semantically by meaning.
• Detect when saved ideas agree, conflict, qualify, or add context to each other.
• Schedule recall so important memories resurface later.
• Run belief audits that show what the user appears to know about a topic, where evidence is strong, and where assumptions may need more support.
• Learn user preferences such as answer style, evidence strictness, topics of interest, and recall behavior.
• Archive memories the user no longer wants surfaced.
• Expose memory tools through an MCP/SSE endpoint.

The goal is not to be a truth oracle. Crowscap does not tell the user, “you are wrong.” It says, “one thing worth considering is...” and lets the user decide whether to refine their knowledge.

How we built it

The frontend is built with Next.js, TypeScript, Tailwind CSS, and TanStack Query. I chose a chat-first interface because it is the most natural way people already work with AI. A user should not need to understand memory graphs, embeddings, or database schemas. They should just be able to say things like “save this,” “remind me later,” “what do I know about this,” or “audit what I believe about startup distribution.”

The backend is built with FastAPI, Pydantic, SQLAlchemy, Alembic, and PostgreSQL with vector search support. Qwen Cloud powers structured extraction, embeddings, routing, relationship detection, audit synthesis, and preference learning.

The memory pipeline works like this:

Capture -> Extract -> Structure -> Relate -> Recall -> Audit -> Adapt

    A key design decision was separating raw sources from memory atoms. The original source remains the evidence, while each extracted atom becomes a small retrievable unit. This lets Crowscap retrieve only the most relevant ideas instead of dumping whole documents into the model context.
For infrastructure, the backend runs on Alibaba Cloud ECS, the AI layer uses Qwen Cloud, and the app exposes an MCP/SSE endpoint so agents can access memory tools.

## Challenges we ran into
     The hardest part was making memory trustworthy.
A normal chatbot can be vague and still feel helpful. A memory agent cannot. If Crowscap claims to remember what a user said, it must retrieve the actual stored message. If it says an idea came from a source, that source must exist. If it says two ideas disagree, the disagreement cannot be forced.
**Some of the hardest challenges were:**
- Preventing normal conversation from becoming accidental memory.
- Handling natural language like “save that,” “yeah,” “remove what I just saved,” and typo-filled questions.
- Avoiding memory pollution from accidental links.
- Making YouTube, URL, and PDF ingestion fail gracefully.
- Managing context windows so irrelevant memories do not reduce answer quality.
- Separating knowledge memory from user preference memory.
- Designing belief audits without pretending the system knows absolute truth.
- Supporting forgetting and archiving instead of storing everything forever.
- Choosing the right Qwen model for each task so the system stayed useful under real latency and cost constraints.

The biggest lesson was that retrieval is not enough. The real problem is judgment: knowing what should enter memory, what should stay out, what should be recalled, and what should be challenged gently.


## Accomplishments that we're proud of
I am proud that Crowscap became more than a basic RAG chatbot.
It has a real memory lifecycle. A saved source becomes structured memory, gets embedded, connected to previous ideas, scheduled for recall, audited for evidence quality, and adapted to user preferences over time.
**I am especially proud of:**
 - Atomic memory extraction from messy real-world content.
 - Source-aware recall and search.
 - Relationship detection between memories.
 - Belief audits that show uncertainty instead of fake certainty.
 - Preference learning that separates how the user wants to learn from what the user has learned.
 - Context-aware recall that surfaces one useful memory instead of overwhelming the user with a queue.
 - A deployed Alibaba Cloud backend with Qwen Cloud integration and MCP/SSE support.
Most importantly, Crowscap started to feel like a system that pays attention, *not just a place where information goes to sleep*.


## What we learned
I learned that memory is not just storage.
Memory requires timing, context, source awareness, and restraint. A good MemoryAgent must know when to remember, when to ask, when to retrieve, when to stay quiet, and when to admit uncertainty.
I also learned that “confidence” is not the same as truth. A memory can be high confidence because it was clearly stated in a source, while still being an opinion, a prediction, or advice that depends on context. That distinction became central to how Crowscap works.

Technically, I learned a lot about building reliable AI systems around Qwen Cloud: structured outputs still need validation, embeddings need careful batching, model latency depends heavily on task choice, and context windows must be actively managed instead of filled blindly.


## What's next for Crowscap

Crowscap is not sitting idle on my repository, the next thing is to make it become more proactive.

The future version will quietly work on saved memories intelligently in the background, finding credible counterpoints, stronger sources, and missing context. Not to judge the user, but to help them notice what they may not have considered.

Planned next steps include:
Stronger proactive perspective notes with public evidence leads.
Better mobile-first recall and notification flows.
More advanced context-window compression.
A richer memory detail view showing source, related ideas, recall history, and evidence strength.
Deeper MCP integration so other agents can use Crowscap as a memory layer.
More evaluation against naive RAG to show the value of atomic memory retrieval.

*The long-term vision is:*
Crowscap should help people not only save what they learn, but become wiser and make better decision because of it.

Built With

• alibaba-cloud
• fastapi
• mcp
• pgvector
• postgresql
• python
• qwen
• qwen-cloud
• rag
• react
• semantic-search
• speced-repetition
• vector-embeddings