> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tastelabs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Find inspiration

> Search the corpus for a look, study the results, and build from a real design system

You know the feeling you want, not the URL that has it. The [Search](/concepts/architecture#the-search) turns a description of an aesthetic into ranked, real brands; the [Extractor](/concepts/architecture#the-extractor) turns the one you pick into a design system you can build from. This guide chains the two.

## The workflow

<Steps>
  <Step title="Describe the look">
    Call [`POST /search`](/api-reference/endpoint/search-brands) with a natural-language `query`. Use `depth: "fast"` while you explore; switch to `depth: "deep"` when you shortlist and quality matters more than latency.

    ```bash theme={null}
    curl -X POST https://api.tastelabs.com/search \
      -H "X-API-Key: your-api-key" \
      -H "Content-Type: application/json" \
      -d '{"query": "moody, grainy portfolio with a weird custom cursor", "top_k": 6}'
    ```
  </Step>

  <Step title="Study the cards">
    Each result card carries an `identity_paragraph` describing the brand's visual identity, `tags`, palette and typography classifications, and a `screenshot_url`. Fetch the screenshots and look at them: the screenshot is the fastest way to judge whether a result has the feeling you described. The `match` tier and `reason` tell you how confident the search is and why the card is there.
  </Step>

  <Step title="Extract the one you pick">
    A card is a pointer into the corpus, not an extraction. Submit its `url` to [`POST /design/submissions`](/api-reference/endpoint/create-submission), poll, and read the full [design system](/concepts/design-system): exact colors, type scale, spacing, components, and the captured screenshot and code.
  </Step>

  <Step title="Build from it">
    Generate from the extracted values directly, or ground a generation prompt in the brand with [`POST /design/prompts/enhance`](/api-reference/endpoint/enhance-prompt), which rewrites your prompt using the extraction's brand profile.
  </Step>
</Steps>

## Write queries that work

A query can lean on a single trait, or mix several into the description of a look:

* A style: `"dark brutalist developer tools"`
* An industry mood: `"warm pastel skincare landing pages"`
* A component or detail: `"brutalist studio site with a marquee ticker"`
* A vibe: `"vintage-feeling site for a clothing brand"`

When a constraint is non-negotiable, move it out of the query and into `filters` (`page_type`, `industry`, `hue`, `layout`). Filters are hard constraints: every result satisfies them. The query, by contrast, is a ranking signal. See [Brand search](/concepts/brand-search#filters).

Repeating a search does not return an identical list: the tail of the results rotates in fresh exemplars of the detected style, marked with `badge: "discovery"`. Treat those as free serendipity.

## Start from a brand instead of a description

Sometimes the starting point is a brand, not words: a competitor, or your own site. [`GET /search/similar`](/api-reference/endpoint/find-similar-brands) takes the `submission_id` of one of your completed extractions and returns its nearest visual neighbours in the corpus. Use it to build a competitor set, answer "which brands look like ours?", or widen a moodboard from one strong example.

Neighbours are computed fresh on every call, so two calls can differ slightly.

## Full example

Search for a look, extract the top result, and read its design system:

```python Python theme={null}
import httpx
import time

API_KEY = "your-api-key"
BASE = "https://api.tastelabs.com"
HEADERS = {"X-API-Key": API_KEY}

search = httpx.post(
    f"{BASE}/search",
    headers=HEADERS,
    json={"query": "dark brutalist developer tools", "depth": "fast", "top_k": 6},
)
search.raise_for_status()
cards = search.json()["results"]
for card in cards:
    print(card["url"], "-", card["identity_paragraph"][:80])

pick = cards[0]
submit = httpx.post(f"{BASE}/design/submissions", headers=HEADERS, json={"url": pick["url"]})
submit.raise_for_status()
submission_id = submit.json()["submission_id"]

while True:
    r = httpx.get(f"{BASE}/design/submissions/{submission_id}/result", headers=HEADERS)
    if r.status_code == 409:
        time.sleep(3)
        continue
    r.raise_for_status()
    body = r.json()
    if body["status"] in ("completed", "failed"):
        break
    time.sleep(3)

design_system = body["result"]["design_system"]
print(design_system["profile"]["brand_name"])
```

## From your agent

The same flow is exposed as [MCP tools](/ai-tools/mcp): `search_brands` for descriptions, `search_similar_brands` for a brand you already extracted, and `extract_brand` to turn a card into a design system. An agent can run the whole search, pick, extract, and build sequence in one conversation. The [`brand-search` skill](/ai-tools/skills#find-references-with-brand-search) teaches it this workflow: route the prompt to the right search tool, write the query from the prompt's own words, and inspect every result before choosing. Pair it with the `brand-adherence` skill when the goal is a page inside the extracted brand's identity.

## Next steps

<CardGroup cols={2}>
  <Card title="Brand search" icon="magnifying-glass" href="/concepts/brand-search">
    Depth, filters, result cards, and search history.
  </Card>

  <Card title="Check brand adherence" icon="scale-balanced" href="/use-cases/brand-adherence">
    Built something from the inspiration? Verify it follows the brand.
  </Card>
</CardGroup>