Web Search

AI search lets a project reach current information from the web, so answers reflect the latest data rather than only the model's training data and the documents you have indexed locally. Every answer that used search is annotated with the sites it drew from.

Getting Started

AI search is powered by the Brave Search API. Brave's free tier includes 1,000 queries per month, which is enough for regular day-to-day use.

1. Sign up at brave.com/search/api.
2. Subscribe to the free plan.
3. Copy your API key.

Bringing your own Brave key means search runs directly against Brave from your machine. Without a key, the app falls back to Smartloop's hosted search endpoint, which is gated by your plan.

Connecting your key

Open Settings and find the Web Search section. Paste your Brave API key into the field and connect it — that is all the setup required.

Once connected, the key is shown masked and can be removed at any time with Disconnect. Your key is stored encrypted on your machine and is never sent anywhere except to Brave when a search runs.

Combining your data

Search is most useful alongside your own data rather than instead of it. Because a project already holds your documents, one prompt can draw on both — your documents for context, the web for what is current.

Product research is a good example. With your existing gear, specifications, or past purchases in the project, you can ask what to buy next: the assistant reads your documents to understand what you already own and what would fit, searches for current models, pricing, and reviews, and then recommends one — with the sites behind the recommendation listed underneath.

Annotated sources

When an answer draws on search results, the sources used are listed in a REFERENCES block beneath it. Web sources link out to the original page, so you can confirm where a claim came from and read further. Documents from your own project appear in the same block, labelled by file type and openable directly — so it is clear at a glance which parts of an answer came from your files and which came from the web.

How it works

1. Your prompt is normalized into a search query — conversational filler such as "can you tell me" is stripped so the query matches the actual subject rather than the phrasing.
2. The query goes to Brave, which returns result links.
3. Up to ten candidate pages are fetched and converted to text (HTML and PDF are both handled).
4. The candidates are reranked by relevance to your question, and the top three are kept as sources for the answer.

If search is unavailable for any reason — turned off for the project, a rejected key, or no results — it is skipped silently and the model answers from what it already knows. You will see an answer without a REFERENCES block rather than an error.

For power users

The Settings page is all most people need. If you would rather script the setup — provisioning a new machine, or turning search on across several projects — the same configuration is available over the local API.

Setup script

This registers your Brave key, confirms it took, then enables search on whichever project is currently active. It needs jq:

#!/usr/bin/env bash
# Configure Brave web search and enable it on the current project.
set -euo pipefail

API="${SLP_API:-http://127.0.0.1:38540/v1}"
KEY="${1:-${SLP_BRAVE_API_KEY:-}}"

if [ -z "$KEY" ]; then
  echo "usage: $(basename "$0") <brave-api-key>" >&2
  echo "Get a free key from https://brave.com/search/api/" >&2
  exit 1
fi

echo "Registering Brave as the search provider..."
curl -fsS -X PUT "$API/search/provider" \
  -H 'Content-Type: application/json' \
  -d "$(jq -n --arg t "$KEY" '{provider: "brave", token: $t}')" >/dev/null

if [ "$(curl -fsS "$API/search/provider" | jq -r '.configured')" != "true" ]; then
  echo "Provider did not register." >&2
  exit 1
fi

project=$(curl -fsS "$API/projects" | jq -r '.projects[] | select(.current) | .id')
if [ -z "$project" ]; then
  echo "No current project found." >&2
  exit 1
fi

echo "Enabling web search on project $project..."
curl -fsS -X PATCH "$API/projects/$project/websearch" \
  -H 'Content-Type: application/json' \
  -d '{"enabled": true}' | jq .

echo "Done."

Save it as enable-web-search.sh, make it executable, and pass your key:

chmod +x enable-web-search.sh
./enable-web-search.sh <your-brave-api-key>

The key is passed to jq as an argument rather than interpolated into the JSON, so characters in it can't break the request. Point SLP_API elsewhere if the agent is not on the default port.

The endpoints

Register the provider, and check what is registered:

curl -X PUT http://127.0.0.1:38540/v1/search/provider \
  -H "Content-Type: application/json" \
  -d '{"provider": "brave", "token": "<your-brave-api-key>"}'

curl http://127.0.0.1:38540/v1/search/provider

{
  "provider": "brave",
  "configured": true,
  "supported": ["brave"]
}

The token itself is never returned — only whether one is configured. To remove it, the equivalent of Disconnect:

curl -X DELETE http://127.0.0.1:38540/v1/search/provider

Search is enabled per project, so you can keep it on for research projects and off for ones that should stay entirely local:

curl -X PATCH http://127.0.0.1:38540/v1/projects/<project_id>/websearch \
  -H "Content-Type: application/json" \
  -d '{"enabled": true}'

{
  "project_id": "f2c60bff-799c-4868-b50e-cf31098648d3",
  "enabled": true
}

Use the id field from GET /v1/projects as the project_id — the active one has "current": true. Send {"enabled": false} to turn it back off, or GET the same path to read the current state.

Using environment variables

A provider can also be supplied through the environment, which takes precedence over the connected key:

export SLP_SEARCH_PROVIDER=brave
export SLP_BRAVE_API_KEY=<your-brave-api-key>

Summary

AI search keeps a project current without giving up local execution: the model and your documents stay on your device, and only the search query leaves it. The annotated references make it clear which parts of an answer came from the web.