Smart Lookup search workflow

Smart Lookup is question-first semantic search for Obsidian.

Use it when you remember the idea, but not the exact phrase, heading, tag, or file name.

The anchor is your question.

If the current note is the anchor, use Smart Connections.
If the exact words matter, use Obsidian native search.
If you need the shape of a topic, use Smart Graph.

The loop

Open Smart Lookup.
Ask one plain-language question.
Expand the strongest results to verify the match.
Open, link, copy, or send the best results to Smart Context.

You know it worked when:

One useful result from your own vault can be verified from the preview, even when the exact words differ.

Choose the right surface

Use the surface that matches the anchor.

Need right now	Start here	Why it fits	You know it worked when...
Current note -> related ideas	Smart Connections	The current note is the anchor.	One related result appears while a note is open.
Question -> semantic search	Smart Lookup	Your query is the anchor.	One result matches the idea, even when the exact words differ.
Exact phrase -> lexical search	Obsidian native search	You need exact words, filenames, tags, headings, syntax, or regex.	The exact match appears.
Landscape -> Graph	Smart Graph	You need clusters, neighborhoods, or the shape of a topic.	One visible region becomes worth selecting.
Reusable set -> Context	Smart Context	Found notes need to become AI-ready context.	A reviewable context bundle is copied or saved.

Lookup is not a replacement for exact search.

Lookup is for the moment when you know the meaning you want, but not the exact wording your notes used.

Query formula

Topic + context nouns + desired output

Good Lookup queries usually include:

the topic or problem
1-3 context nouns that name the domain
the kind of result you want

Examples:

"My notes about reducing information overload while researching - list the best steps."
"Prior decisions about the Smart Context Builder - summarize tradeoffs."
"Notes related to customer onboarding friction - find examples and next actions."
"Ideas about local-first AI and user control - find the strongest arguments."

Start broad enough to catch the idea.
Then add 1-2 constraints if the results are too wide.

Quick start

Open Smart Lookup.
Type one plain-language query.
Scan the top results.
Expand 1-2 promising results before deciding.
Open, link, copy, or send the strongest match to Smart Context.

A good first query is about work you are actually doing now.
Avoid testing with a vague demo question unless your vault has enough matching material to make the result meaningful.

How to read Lookup results

Semantic results are candidates for review, not conclusions.

Use this review loop:

Scan the top results.
Expand 1-2 results.
Confirm relevance from the excerpt or preview.
Open the best note when you need the full source.
Send the strongest results to Smart Context when you are preparing an AI handoff.

Treat score and rank as signals.
They help you decide what to inspect first, but they do not prove that the top result is the right result.

If a result is related but not useful, refine the query or use it as a clue for better context nouns.

When results are weak

Do the smallest recovery that matches the symptom.

Symptom	Try first	Why
Results are too broad	Add 1-2 context nouns or a desired output.	Lookup needs enough intent to shape semantic retrieval.
Results are too narrow	Remove one constraint or use a broader topic phrase.	Over-specific queries can miss useful neighboring notes.
The exact phrase does not appear	Use Obsidian native search.	Exact words, tags, headings, filenames, and regex are lexical jobs.
You are looking from one active note	Use Smart Connections.	Connections is current-note-first.
You need topic shape, not a list	Use Smart Graph.	Graph is for clusters, neighborhoods, and landscape.
Results are empty or stale	Check Smart Environment readiness.	Import or embeddings may still be preparing.

If this is your first run, check readiness before judging Lookup quality:

Sources vs blocks

Lookup can return different levels of results depending on your Smart Environment and Connections settings.

Result type	Best when	Tradeoff
Sources	You want broader note discovery.	Easier to scan, but may require opening the note to find the exact section.
Blocks	Long notes hide the useful section.	More precise, but can create more candidates and may require more tuning.

Start with Sources when you are learning the workflow.
Use Blocks when you know note-level results are too broad.

For tuning, see Smart Connections settings.

Found the right notes. Now what?

Retrieval is only half the job.

When a Lookup result should feed AI work:

Select or open the strongest results.
Send or copy them into Smart Context.
Review the context bundle.
Paste it into Smart Chat, ChatGPT, Claude, Gemini, or another AI tool.
Ask for the outcome you want.

Use this prompt starter:

Using only the attached context, summarize the useful evidence, list the strongest next actions, and flag any missing information before recommending a plan.

Recover an idea when you do not remember the words

Ask the idea in plain language.
Expand the top results.
Open the note that confirms the match.
Add a link back to the current work.

Build a reading trail

Ask a topic-level query.
Open or copy the top useful results.
Create a ranked reading trail note.
Work top-down from the strongest matches.

Prepare context for AI

Ask the question your AI workflow needs to answer.
Select the strongest notes from the results.
Send them to Smart Context.
Remove noise before copying the final bundle.
Delegate in Smart Chat or your current AI tool.

FAQ

Does Lookup replace Obsidian search?

No.

Use Lookup when meaning is the anchor.
Use Obsidian search when exact words, tags, headings, filenames, syntax, or regex are the anchor.

Is Lookup the same as Connections?

No.

Connections answers: "What is related to the note I am looking at right now?"

Lookup answers: "What notes are about this question or idea?"

They use related semantic retrieval ideas, but they start from different anchors.

Why did Lookup return a result without my exact words?

That is often the point.

Lookup retrieves by meaning, so it can surface notes that use different vocabulary.
If you need exact wording, use Obsidian search.

Should I trust the top result?

Preview before you trust it.

The top result is a candidate to inspect first, not a guarantee of truth.

What should I do after I find the note?

Open it, link it, copy it, or send it to Smart Context.

Do not stop at scanning results if the result should become part of the work.