With Weaviate you can query your data using [vector similarity search](similarity.md), [keyword search](bm25.md), or a mix of both with [hybrid search](hybrid.md). You can control what object [properties](#retrieve-object-properties) and [metadata](#retrieve-metadata-values) to return.

This page provides fundamental search syntax to get you started.

:::callout{intent="tip" title="Prefer natural language queries?"}
The [Query Agent](query-agent.md) translates plain English questions into optimized Weaviate queries automatically - no manual query construction needed.
Cloud only
:::

## List objects

You can get objects without specifying any parameters. This returns objects in ascending UUID order.

:::code-group{sync="languages"}
```python title="Python" {2}
jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects()

for o in response.objects:
    print(o.properties)
```

```typescript title="JavaScript/TypeScript"
const myCollection = client.collections.use('JeopardyQuestion');
```

```go title="Go"
response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithFields(graphql.Field{Name: "question"}).
  Do(ctx)
```

```java title="Java" {3}
CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects();

for (var o : response.objects()) {
  System.out.println(o.properties());
}
```

```csharp title="C#" {2}
var jeopardy = client.Collections.Use("JeopardyQuestion");
var response = await jeopardy.Query.FetchObjects();

foreach (var o in response.Objects)
{
    Console.WriteLine(JsonSerializer.Serialize(o.Properties));
}
```

```graphql title="GraphQL"
{
  Get {
    JeopardyQuestion {
      question
    }
  }
}
```
:::

:::accordion{title="Example response"}
The output is like this:

```json
{
  "data": {
    "Get": {
      "JeopardyQuestion": [
        {
          "question": "This prophet passed the time he spent inside a fish offering up prayers"
        },
        // shortened for brevity
      ]
    }
  }
}
```
:::

:::accordion{title="Additional information"}
Specify the information that you want your query to return. You can return object properties, object IDs, and object metadata.
:::

## `limit` returned objects

Use `limit` to set a fixed maximum number of objects to return.

:::code-group{sync="languages"}
```python title="Python" {3}
jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects(
    limit=1
)

for o in response.objects:
    print(o.properties)
```

```typescript title="JavaScript/TypeScript"
const myCollection = client.collections.use('JeopardyQuestion');
```

```go title="Go" {4}
response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithFields(graphql.Field{Name: "question"}).
  WithLimit(1).
  Do(ctx)
```

```java title="Java" {4}
CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects(
    q -> q.limit(1)
);

for (var o : response.objects()) {
  System.out.println(o.properties());
}
```

```csharp title="C#" {3}
var jeopardy = client.Collections.Use("JeopardyQuestion");
var response = await jeopardy.Query.FetchObjects(
    limit: 1
);

foreach (var o in response.Objects)
{
    Console.WriteLine(JsonSerializer.Serialize(o.Properties));
}
```

```graphql title="GraphQL" {4}
{
  Get {
    JeopardyQuestion (
      limit: 1
    ) {
      question
    }
  }
}
```
:::

:::accordion{title="Example response"}
The output is like this:

```json
{
  "data": {
    "Get": {
      "JeopardyQuestion": [
        {
          "question": "This prophet passed the time he spent inside a fish offering up prayers"
        },
        // Note this will only have one result as we limited it to 1
      ]
    }
  }
}
```
:::

## Paginate with `limit` and `offset`

To start in the middle of your result set, define an `offset`. Set a `limit` to return objects starting at the offset.

:::code-group{sync="languages"}
```python title="Python" {3-4}
jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects(
    limit=1,
    offset=1
)

for o in response.objects:
    print(o.properties)
```

```typescript title="JavaScript/TypeScript"
const myCollection = client.collections.use('JeopardyQuestion');
```

```go title="Go" {4-5}
response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithFields(graphql.Field{Name: "question"}).
  WithLimit(1).
  WithOffset(1).
  Do(ctx)
```

```java title="Java" {4}
CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects(
    q -> q.limit(1).offset(1)
);

for (var o : response.objects()) {
  System.out.println(o.properties());
}
```

```csharp title="C#" {2}
var jeopardy = client.Collections.Use("JeopardyQuestion");
var response = await jeopardy.Query.FetchObjects(offset: 1, limit: 1);

foreach (var o in response.Objects)
{
    Console.WriteLine(JsonSerializer.Serialize(o.Properties));
}
```

```graphql title="GraphQL" {4-5}
{
  Get {
    JeopardyQuestion (
      limit: 1
      offset: 1
    ) {
      question
    }
  }
}
```
:::

:::accordion{title="Example response"}
The output is like this:

```json
{
  "data": {
    "Get": {
      "JeopardyQuestion": [
        {
          "question": "Pythons are oviparous, meaning they do this"
        }
      ]
    }
  }
}
```
:::

To paginate through the entire database, use a [cursor](../how-to-manage-objects/read-all-objects.md) instead of offset and limit.

## Retrieve object `properties`

You can specify which object properties to return. By default, all properties and object UUIDs are returned. Blob and reference properties are excluded unless specified otherwise (_this does not apply to the Go client library_).

:::code-group{sync="languages"}
```python title="Python" {3-4}
jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects(
    limit=1,
    return_properties=["question", "answer", "points"]
)

for o in response.objects:
    print(o.properties)
```

```typescript title="JavaScript/TypeScript"
const myCollection = client.collections.use('JeopardyQuestion');
```

```go title="Go" {3-7}
response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithFields(
    graphql.Field{Name: "question"},
    graphql.Field{Name: "answer"},
    graphql.Field{Name: "points"},
  ).
  WithLimit(1).
  Do(ctx)
```

```java title="Java" {4}
CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects(
    q -> q.limit(1).returnProperties("question", "answer", "points")
);

for (var o : response.objects()) {
  System.out.println(o.properties());
}
```

```csharp title="C#" {3-4}
var jeopardy = client.Collections.Use("JeopardyQuestion");
var response = await jeopardy.Query.FetchObjects(
    limit: 1,
    returnProperties: new[] { "question", "answer", "points" }
);

foreach (var o in response.Objects)
{
    Console.WriteLine(JsonSerializer.Serialize(o.Properties));
}
```

```graphql title="GraphQL" {4-6}
{
  Get {
    JeopardyQuestion (limit: 1) {
      question
      answer
      points
    }
  }
}
```
:::

:::accordion{title="Example response"}
The output is like this:

```json
{
  "data": {
    "Get": {
      "JeopardyQuestion": [
        {
          "answer": "Jonah",
          "points": 100,
          "question": "This prophet passed the time he spent inside a fish offering up prayers"
        },
      ]
    }
  }
}
```
:::

## Retrieve the object `vector`

You can retrieve the object vector. (Also applicable where [named vectors](../reference-configuration/collections.md#multiple-vector-embeddings-named-vectors) are used.)

:::code-group{sync="languages"}
```python title="Python" {3}
jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects(
    include_vector=True,
    limit=1
)

print(response.objects[0].vector["default"])
```

```typescript title="JavaScript/TypeScript"
const myCollection = client.collections.use('JeopardyQuestion');
```

```go title="Go" {3-10}
response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithFields(
    graphql.Field{
      Name: "_additional",
      Fields: []graphql.Field{
        {Name: "vector"},
      },
    },
  ).
  WithLimit(1).
  Do(ctx)
```

```java title="Java" {4}
CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects(q -> q
    .includeVector()
    .limit(1));

if (!response.objects().isEmpty()) {
  System.out.println(response.objects().get(0).vectors());
}
```

```csharp title="C#" {3}
var jeopardy = client.Collections.Use("JeopardyQuestion");
var response = await jeopardy.Query.FetchObjects(
    includeVectors: new[] { "default" },
    limit: 1
);

Console.WriteLine("Vector for 'default':");
if (response.Objects.Any())
{
    Console.WriteLine(JsonSerializer.Serialize(response.Objects.First()));
}
```

```graphql title="GraphQL" {4-6}
{
  Get {
    JeopardyQuestion (limit: 1) {
      _additional {
        vector
      }
    }
  }
}
```
:::

:::accordion{title="Example response"}
The output is like this:

```json
{
  "data": {
    "Get": {
      "JeopardyQuestion": [
        {
          "_additional": {
            "vector": [
              0.0065065133,
              -0.017786196,
              0.005879146,
              0.006707012,
              ...  // shortened for brevity
            ]
          }
        },
      ]
    }
  }
}
```
:::

## Retrieve the object `id`

You can retrieve the object `id` (uuid).

:::code-group{sync="languages"}
```python title="Python"
jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects(
    # Object IDs are included by default with the `v4` client! :)
    limit=1
)

for o in response.objects:
    print(o.uuid)
```

```typescript title="JavaScript/TypeScript"
const myCollection = client.collections.use('JeopardyQuestion');
```

```go title="Go" {3-10}
response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithFields(
    graphql.Field{
      Name: "_additional",
      Fields: []graphql.Field{
        {Name: "id"},
      },
    },
  ).
  WithLimit(1).
  Do(ctx)
```

```java title="Java"
CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects(
    // Object IDs are included by default with the v6 client! :)
    q -> q.limit(1));

for (var o : response.objects()) {
  System.out.println(o.uuid());
}
```

```csharp title="C#"
var jeopardy = client.Collections.Use("JeopardyQuestion");
// Ensure you use a UUID that actually exists in your DB, or fetch one first
var allObjs = await jeopardy.Query.FetchObjects(limit: 1);
var idToFetch = allObjs.Objects.First().UUID;

var response = await jeopardy.Query.FetchObjectByID((Guid)idToFetch);

Console.WriteLine(response);
```

```graphql title="GraphQL" {4-6}
{
  Get {
    JeopardyQuestion (limit: 1) {
      _additional {
        id
      }
    }
  }
}
```
:::

:::accordion{title="Example response"}
The output is like this:

```json
{
  "data": {
    "Get": {
      "JeopardyQuestion": [
        {
          "_additional": {
            "id": "0002bf92-80c8-5d94-af34-0d6c5fea1aaf"
          }
        },
        // shortened for brevity
      ]
    }
  }
}
```
:::

## Retrieve cross-referenced properties

:::callout{intent="warning" title="Cross-references and query performance"}
Queries involving cross-references can be slower than queries that do not involve cross-references, especially at scale such as for multiple objects or complex queries.

At the first instance, we strongly encourage you to consider whether you can avoid using cross-references in your data schema. As a scalable AI database, Weaviate is well-placed to perform complex queries with vector, keyword and hybrid searches involving filters. You may benefit from rethinking your data schema to avoid cross-references where possible.

For example, instead of creating separate "Author" and "Book" collections with cross-references, consider embedding author information directly in Book objects and using searches and filters to find books by author characteristics.
:::

To retrieve properties from cross-referenced objects, specify:

- The cross-reference property
- The target cross-referenced collection
- The properties to retrieve

:::code-group{sync="languages"}
```python title="Python" {5-10}
from weaviate.classes.query import QueryReference

jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects(
    return_references=[
        QueryReference(
            link_on="hasCategory",
            return_properties=["title"]
        ),
    ],
    limit=2
)

for o in response.objects:
    print(o.properties["question"])
    # print referenced objects
    for ref_obj in o.references["hasCategory"].objects:
        print(ref_obj.properties)
```

```typescript title="JavaScript/TypeScript"
const myCollection = client.collections.use('JeopardyQuestion');
```

```go title="Go" {3-11}
response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithFields(
    graphql.Field{Name: "question"},
    graphql.Field{
      Name: "hasCategory",
      Fields: []graphql.Field{
        {Name: "... on JeopardyCategory", Fields: []graphql.Field{{Name: "title"}}},
      },
    },
  ).
  WithLimit(2).
  Do(ctx)
```

```java title="Java" {4-5}
CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects(q -> q
    .returnReferences(QueryReference.single("hasCategory",
        r -> r.returnProperties("title")))
    .limit(2));

for (var o : response.objects()) {
  System.out.println(o.properties().get("question"));
  // print referenced objects
  if (o.references() != null && o.references().get("hasCategory") != null) {
    for (var refObj : o.references().get("hasCategory")) {
      System.out.println(refObj);
    }
  }
}
```

```csharp title="C#" {3}
var jeopardy = client.Collections.Use("JeopardyQuestion");
var response = await jeopardy.Query.FetchObjects(
    returnReferences: [new QueryReference(linkOn: "hasCategory", fields: ["title"])],
    limit: 2
);

foreach (var o in response.Objects)
{
    if (o.Properties.ContainsKey("question"))
        Console.WriteLine(o.Properties["question"]);

    // print referenced objects
    // Note: References are grouped by property name ('hasCategory')
    if (o.References != null && o.References.ContainsKey("hasCategory"))
    {
        foreach (var refObj in o.References["hasCategory"])
        {
            Console.WriteLine(JsonSerializer.Serialize(refObj.Properties));
        }
    }
}
```

```graphql title="GraphQL" {6-13}
{
  Get {
    JeopardyQuestion (
      limit: 2
    )
    {
      question
      hasCategory {
        ... on JeopardyCategory {
          title
        }
      }
    }
  }
}
```
:::

:::accordion{title="Example response"}
The output is like this:

```json
{
    "data": {
        "Get": {
            "JeopardyQuestion": [
                {
                    "hasCategory": [{"title": "THE BIBLE"}],
                    "question": "This prophet passed the time he spent inside a fish offering up prayers",
                },
                {
                    "hasCategory": [{"title": "ANIMALS"}],
                    "question": "Pythons are oviparous, meaning they do this",
                },
            ]
        }
    }
}
```
:::

## Retrieve metadata values

You can specify metadata fields to be returned.

:::code-group{sync="languages"}
```python title="Python" {6}
from weaviate.classes.query import MetadataQuery

jeopardy = client.collections.use("JeopardyQuestion")
response = jeopardy.query.fetch_objects(
    limit=1,
    return_metadata=MetadataQuery(creation_time=True)
)

for o in response.objects:
    print(o.properties)  # View the returned properties
    print(o.metadata.creation_time)  # View the returned creation time
```

```typescript title="JavaScript/TypeScript"
const myCollection = client.collections.use('JeopardyQuestion');
```

```go title="Go" {4-12}
response, err := client.GraphQL().Get().
  WithClassName("JeopardyQuestion").
  WithLimit(1).
  WithFields(
    graphql.Field{Name: "question"},
    graphql.Field{
      Name: "_additional",
      Fields: []graphql.Field{
        {Name: "creationTimeUnix"},
      },
    },
  ).
  Do(ctx)
```

```java title="Java" {4}
CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("JeopardyQuestion");
var response = jeopardy.query.fetchObjects(q -> q.limit(1)
    .returnMetadata(Metadata.CREATION_TIME_UNIX)
);

for (var o : response.objects()) {
  System.out.println(o.properties()); // View the returned properties
  System.out.println(o.createdAt()); // View the returned creation time
}
```

```csharp title="C#" {4}
var jeopardy = client.Collections.Use("JeopardyQuestion");
var response = await jeopardy.Query.FetchObjects(
    limit: 1,
    returnMetadata: MetadataOptions.CreationTime
);

foreach (var o in response.Objects)
{
    Console.WriteLine(JsonSerializer.Serialize(o.Properties)); // View the returned properties
    Console.WriteLine(o.Metadata.CreationTime); // View the returned creation time
}
```

```graphql title="GraphQL" {7}
{
  Get {
    JeopardyQuestion (
      limit: 1
    ) {
      question
      _additional { creationTimeUnix }
    }
  }
}
```
:::

For a comprehensive list of metadata fields, see [GraphQL: Additional properties](../apis/graphql-additional-properties.md).

:::callout{intent="tip" title="Debugging query performance"}
Use [query profiling](query-profile.md) to get per-shard timing breakdowns for any search query. Add `query_profile=True` to `MetadataQuery` to see exactly how long each phase takes.
:::

## Multi-tenancy

If [multi-tenancy](../concepts/data.md#multi-tenancy) is enabled, specify the tenant parameter in each query.

:::code-group{sync="languages"}
```python title="Python" {5}
# Connect to the collection
mt_collection = client.collections.use("WineReviewMT")

# Get the specific tenant's version of the collection
collection_tenant_a = mt_collection.with_tenant("tenantA")

# Query tenantA's version
response = collection_tenant_a.query.fetch_objects(
    return_properties=["review_body", "title"],
    limit=1,
)

print(response.objects[0].properties)
```

```typescript title="JavaScript/TypeScript" {2}
const myMTCollection = client.collections.use('WineReviewMT');
const collectionTenantA = myMTCollection.withTenant('tenantA');

const multiTenantResult = await collectionTenantA.query.fetchObjects({
  limit: 1,
  returnProperties: ['review_body','title']
})

console.log(JSON.stringify(multiTenantResult.objects[0].properties, null, 2));
```

```go title="Go" {5}
response, err := client.GraphQL().Get().
  WithClassName("MultiTenancyClass").
  WithFields(graphql.Field{Name: "property1"}, graphql.Field{Name: "property2"}).
  WithLimit(1).
  WithTenant("tenantA").
  Do(ctx)
```

```java title="Java" {6}
// Connect to the collection
CollectionHandle<Map<String, Object>> mtCollection =
    client.collections.use("WineReviewMT");

// Get the specific tenant's version of the collection
var collectionTenantA = mtCollection.withTenant("tenantA");

// Query tenantA's version
var response = collectionTenantA.query
    .fetchObjects(q -> q.returnProperties("review_body", "title").limit(1));

if (!response.objects().isEmpty()) {
  System.out.println(response.objects().get(0).properties());
}
```

```csharp title="C#"
var mtCollection = client.Collections.Use("WineReviewMT").WithTenant("tenantA");

var response = await mtCollection.Query.FetchObjects(
    returnProperties: new[] { "review_body", "title" },
    limit: 1
);

if (response.Objects.Any())
{
    Console.WriteLine(JsonSerializer.Serialize(response.Objects.First().Properties));
    Assert.Equal("WineReviewMT", response.Objects.First().Collection);
}
```
:::

## Replication

For collections with replication enabled, you can specify the consistency level in your queries. This applies to CRUD queries as well as searches.

:::code-group{sync="languages"}
```python title="Python"
from weaviate.classes.config import ConsistencyLevel
```

```typescript title="JavaScript/TypeScript" {1}
const myCollection = client.collections.use('Article').withConsistency('QUORUM');

const result = await myCollection.query.fetchObjectById("36ddd591-2dee-4e7e-a3cc-eb86d30a4303")

console.log(JSON.stringify(result, null, 2));

// The parameter passed to `withConsistencyLevel` can be one of:
// * 'ALL',
// * 'QUORUM' (default), or
// * 'ONE'.
//
// It determines how many replicas must acknowledge a request
// before it is considered successful.
```

```go title="Go"
package main

import (
    "context"
    "fmt"

    "github.com/weaviate/weaviate-go-client/v5/weaviate/data/replication"  // for consistency levels
    "github.com/weaviate/weaviate-go-client/v5/weaviate"
)

func main() {
    cfg := weaviate.Config{
        Host:   "localhost:8080",
        Scheme: "http",
    }
    client, err := weaviate.NewClient(cfg)
    if err != nil {
        panic(err)
    }

    data, err := client.Data().ObjectsGetter().
        WithClassName("MyClass").
        WithID("36ddd591-2dee-4e7e-a3cc-eb86d30a4303").
        WithConsistencyLevel(replication.ConsistencyLevel.ONE).  // default QUORUM
        Do(context.Background())

    if err != nil {
        panic(err)
    }
    fmt.Printf("%v", data)
}

// The parameter passed to "WithConsistencyLevel" can be one of:
// * replication.ConsistencyLevel.ALL,
// * replication.ConsistencyLevel.QUORUM (default), or
// * replication.ConsistencyLevel.ONE.
//
// It determines how many replicas must acknowledge a request
// before it is considered successful.

```

```java title="Java" {3}
var jeopardyWithConsistency = client.collections.use("JeopardyQuestion")
    .withConsistencyLevel(ConsistencyLevel.QUORUM);
var response = jeopardyWithConsistency.query.fetchObjectById(uuid);

System.out.println(response.get().properties());
```

```csharp title="C#"
var jeopardy = client
    .Collections.Use("JeopardyQuestion")
    .WithConsistencyLevel(ConsistencyLevels.Quorum);

var response = await jeopardy.Query.FetchObjectByID((Guid)validId);

// The parameter passed to `withConsistencyLevel` can be one of:
// * 'ALL',
// * 'QUORUM' (default), or
// * 'ONE'.
//
// It determines how many replicas must acknowledge a request
// before it is considered successful.

Console.WriteLine(response);
```

```bash title="Curl"
curl "http://localhost:8080/v1/objects/MyClass/36ddd591-2dee-4e7e-a3cc-eb86d30a4303?consistency_level=QUORUM"

# The parameter "consistency_level" can be one of ALL, QUORUM (default), or ONE. Determines how many
# replicas must acknowledge a request before it is considered successful.
# curl "/v1/objects/{ClassName}/{id}?consistency_level=ONE"
```
:::

## Related pages

- [Connect to Weaviate](../connect-to-weaviate/index.md)
- [API References: GraphQL: Get](../apis/graphql-get.md)
- For search using the GraphQL API, see [GraphQL API](../apis/graphql-get.md)

## Questions and feedback

Have a question or feedback? Here's how to reach us.

::::card-grid
:::card{title="Community Forum" href="https://forum.weaviate.io/c/support" icon="messages-square"}
Ask questions and connect with other developers on our **Community forum**.
:::

:::card{title="Support" href="/guides/support-overview" icon="life-buoy"}
Weaviate Cloud user or customer? Find the right channel on the **Support page**.
:::
::::

## Related pages

- [Agents](./agents-index.md)
- [AI-assisted Weaviate code generation](./ai-assisted-vibe-coding-index.md)
- [APIs](./apis-index.md)
- [Authorization and authentication](./authorization-and-authentication-index.md)
- [Benchmarks](./benchmarks-index.md)
- [Best practices](./best-practices-index.md)
- [Client libraries](./clients-index.md)
- [Client Libraries / SDKs](./client-libraries-index.md)
- [Cloud](./cloud-index.md)
- [Cloud account management](./cloud-account-management-index.md)

# Agent Instructions

This portal answers questions programmatically. To receive a synthesized,
source-cited answer instead of crawling page by page, append the `?ask=`
query parameter to any page URL on this site:

    /guides/quickstart?ask=how+do+I+authenticate

Optional parameters:

- `&goal=<what-you-are-trying-to-do>` steers the answer toward your
  objective (e.g. `&goal=write+a+python+client`).
- `&version=<label>` scopes the answer to a mounted version when the
  portal publishes more than one.

The response is `text/markdown`: the answer followed by a `# Sources` list
of the portal pages it was grounded in. Status codes are the contract:

- `200` — the answer; `402` — the portal owner’s plan or answer credits are
  exhausted (surface this to your operator; do NOT retry); `429` — you are
  rate-limited; back off for the `Retry-After` seconds; `503` — the answer
  lane is temporarily unavailable; fall back to crawling the `.md` pages.

For the full corpus map read `llms.txt` at the site root; for the tool
surface (search + page fetch as MCP tools) see `/mcp`.