A persistent canvas of tagged, searchable notes that the agent can read, write, and retrieve. Capture ad-hoc ideas, collect agent insights, and build a living reference layer that grows with every project.
Notes survive across sessions, browser tabs, and server restarts. They're stored in the SQLite database alongside the rest of Guaardvark's entities, not in browser localStorage or a markdown file that disappears when you close a tab. The canvas shows your most recent notes on dashboard load, and a full-page view lets you browse all notes with sorting and filtering.
Apply arbitrary tags to notes at creation or edit time. Filter the canvas by tag to surface the relevant subset quickly. Full-text search across note content finds terms across all notes instantly. Combine tag filters with text search to narrow to the exact subset you need — all notes tagged hypothesis containing the word "latency", for example.
Every note is indexed into the project's LlamaIndex vector store alongside uploaded documents. The agent can retrieve notes semantically during chat — if you've pinned a decision rationale as a sticky note, the agent finds it when asked why a particular approach was chosen, even if the note doesn't contain the exact words used in the query.
The agent can create sticky notes as part of its ReACT loop. During a research task, it can pin key findings, decision points, or uncertainties as notes rather than losing them in the chat scroll. You can instruct the agent to maintain a running notes board for a long project, and the board persists even after the conversation context has been compacted.
Guaardvark chat sessions are valuable but ephemeral at the context level — a long conversation compacts, older turns leave the active window, and insights buried in a three-hour session become hard to retrieve. Sticky Notes provides a durable, immediately queryable layer that sits alongside chat. When you have an insight mid-conversation, pin it as a note. When the agent produces a useful finding, ask it to save the finding to the notes board. When you start a new session days later, the notes are right there, and the RAG index means the new agent session can retrieve them without you having to paste them back in.
Notes are scoped to the active project, consistent with the rest of Guaardvark's workspace isolation model. A note created in a client project stays in that project's canvas and that project's RAG index. Notes from other projects don't appear in the sidebar or surface in chat responses. This means you can freely pin speculative or confidential observations without worrying about them leaking into an unrelated project's agent context.
The tag system uses free-form labels rather than a fixed taxonomy, so you can evolve your tagging vocabulary as a project progresses. Common patterns include task state tags (todo, done, blocked), epistemic status tags (hypothesis, verified, uncertain), and content type tags (decision, question, reference). The combination of tag filtering and semantic search means that even a board with hundreds of notes remains navigable. The agent-writable capability closes the loop: you don't have to manually transcribe insights from chat to the notes board; you can delegate that to the agent as part of its task.
Storage and indexing. Sticky Notes are stored as a specialised document type in the SQLite database, scoped by project_id. On creation or edit, the note content is re-indexed into the project's LlamaIndex vector store via the same indexing_service.py pipeline used for uploaded documents. The embedding is generated by the embedding_router.py — CPU via Ollama embeddings or GPU via the gpu_embedding plugin if available. Deleting a note removes it from both the database and the vector store index. The indexing is lightweight because note content is typically short, so re-indexing on each edit is fast enough to be synchronous for notes under approximately 2,000 characters.
Agent tool integration. The agent's tool registry includes a create_sticky_note and a search_sticky_notes tool bound in backend/tools/content_tools.py. During the ReACT loop, the agent can call these tools to save findings or retrieve relevant prior notes. The tools are registered with a schema that accepts title, content, and tags, matching the same fields exposed by the Notes API. Agent-created notes are indistinguishable from user-created notes in the canvas and are equally retrievable in future sessions.
# Create a note via the API
curl -X POST http://localhost:5000/api/notes -H "Content-Type: application/json" -d '{
"project_id": "proj_abc",
"title": "Key finding: latency correlates with chunk size",
"content": "RAG retrieval latency scales approximately linearly with chunk size above 512 tokens. Switching to 256-token chunks reduced p95 from 850ms to 340ms.",
"tags": ["performance", "rag", "verified"]
}'
# Search notes semantically
curl "http://localhost:5000/api/notes/search?q=retrieval+latency&project_id=proj_abc"Instruct the agent to pin a daily summary note at the end of each research session. Over weeks, the notes board accumulates a chronological log of findings, decisions, and open questions. New sessions begin with the agent loading recent notes as context, so it resumes where you left off without you having to reconstruct the prior work verbally.
When you make a significant architectural or strategic decision, pin the rationale as a sticky note tagged decision. Six months later when someone asks why that approach was chosen, the agent retrieves the rationale note semantically and cites it in its answer. The note doesn't require exact keyword matching — the vector index finds it from conceptual proximity.
When running a long agent task — web research, codebase analysis, content generation — configure the agent to save notable intermediate findings as sticky notes rather than relying on you to read the full chat transcript. At the end of the run, review the notes board for the distilled insights. The notes also serve as a progress indicator: watching them accumulate tells you the agent is making forward progress.
External note tools like Notion, Obsidian, or Apple Notes store content that is completely disconnected from your AI assistant. Bridging them requires copy-paste, plugins, or API integrations that are fragile and unidirectional. Guaardvark Sticky Notes are a first-class entity in the same database that powers RAG retrieval, agent tool calls, and project scoping. The agent can create, read, and search notes in the same ReACT loop where it processes documents, generates content, and executes code. Notes and documents live in the same vector index, so a semantic search surfaces relevant information regardless of whether it came from an uploaded PDF or a pinned note.
Yes. Notes are indexed into the project's LlamaIndex vector store at creation time and are retrieved alongside document chunks during RAG-augmented chat. There is no distinction between notes and document chunks from the retrieval engine's perspective — both are vector embeddings in the same index. Notes are tagged with a source=sticky_note metadata field so the agent can distinguish them in citations if needed.
Yes. The Notes API supports bulk export as a JSON array or as a Markdown file with one note per section. The llx CLI will expose a notes export command. Notes are also included in the full system backup produced by backup_service.py.
No hard limit. Notes are stored as TEXT fields in SQLite (unlimited length). Very long notes will have their embeddings chunked by the same enhanced chunker used for documents, so only the semantically relevant portion of a long note surfaces in retrieval rather than the entire content. For most use cases — observations, decisions, short summaries — notes stay well under 500 characters and are embedded as a single chunk.
Notes use a flat tag-based organisation rather than folders. The tag filter and full-text search combination is more flexible than a hierarchy for the ad-hoc capture use case, where you often don't know the right folder structure in advance. If you need hierarchical organisation for longer structured content, the Documents feature with its folder-based file browser is a better fit.
Only when retrieved. Notes are not injected into every prompt; they surface through the same RAG retrieval pipeline as documents. If the current query is semantically similar to a note's content, the note will be retrieved and included in the context. If not, it stays dormant in the index. This prevents note accumulation from inflating prompt length in unrelated conversations.