# Glossary

```mdx-code-block
<APITable>
```

| Term                                             | Description                                                                                                                                                                                                                                                                                                                                                                                                                         |
| :----------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Aggregation**                                  | The process of computing summaries or statistics over a set of query results (e.g., counting objects, finding min/max/mean of properties). Typically performed using the GraphQL `Aggregate{}` function.                                                                                                                                                                                                                            |
| **API key**                                      | A secret token used for authenticating requests to a Weaviate instance (especially for Weaviate Cloud) or to integrated third-party services like model providers (e.g., OpenAI, Cohere).                                                                                                                                                                                                                                           |
| **Beacon**                                       | A beacon is a reference to a particular data object in Weaviate or inside the knowledge network. This data object in turn has a position in the vector space. Often defined as follows: `weaviate://{peerName}/{className}/{UUID}`. (For Weaviate version < `v1.14.0`, it is defined as follows: `weaviate://{peerName}/{UUID}`.)                                                                                                   |
| **Class**                                        | A class is the former name for a [collection](../starter-guides/managing-collections.md), a container where data objects sharing the same structure (properties, vectorizer settings, etc.) are stored.                                                                                                                                                                                                                             |
| **Concept**                                      | Concepts are related to entities. Often you will use concepts to search in your datasets. If your dataset has data about _An Actor with the name Arnold Schwarzenegger_ and _an Actor with the name Al Pacino_, the concepts _Movie_ and _Terminator_ will find a closer relation to the first actor rather than the latter.                                                                                                        |
| **Contextionary**                                | Derived from _dictionary_ with _context_. Pre-trained vector space which contains vectors for nearly all words used in a specific language. The Contextionary (text2vec-contextionary) gives context to the language used in the dataset, inspired by the [_Global Vectors for Word Representation_](https://github.com/stanfordnlp/GloVe) concept. Read more about the Contextionary [here](../modules/text2vec-contextionary.md). |
| **Embedding model**                              | A machine learning model that transforms data (text, images, audio, etc.) into numerical vector representations (embeddings). This is the core component within a Vectorizer module.                                                                                                                                                                                                                                                |
| **Entity**                                       | An entity refers to something -often- in the world around us. E.g., _a Company with the name Apple_ refers to an entity with a relation to _a Product with the name iPhone_. Weaviate's Contextionary tries to find as many entities in your data as possible.                                                                                                                                                                      |
| **Fuzzy**                                        | Opposed to most other data solutions, Weaviate uses [fuzzy logic](https://en.wikipedia.org/wiki/Fuzzy_logic) to interpret a query. The upside of this is that it might find answers to queries where a traditional data solution might not.                                                                                                                                                                                         |
| **Generative model**                             | An AI model integrated with Weaviate (often via a module like `generative-openai`) that can generate new content (e.g., summaries, answers) based on the context provided by search results.                                                                                                                                                                                                                                        |
| **HNSW**                                         | Hierarchical Navigable Small World - a multilayered graph vector index type.                                                                                                                                                                                                                                                                                                                                                        |
| **Inverted index**                               | An index storing a mapping from data property values, to its locations of data objects in a database (named in contrast to a forward index, which maps from data objects to property data values).                                                                                                                                                                                                                                  |
| **Model provider integrations**                  | Weaviate's ability to connect with external services (like OpenAI, Cohere, Hugging Face, Google Vertex AI) that host and serve machine learning models (Embedding models, Generative models, Rerankers) used within Weaviate modules.                                                                                                                                                                                               |
| **Multimodal**                                   | The capability to process and understand information from multiple types (modalities) of data simultaneously, such as text, images, audio, etc. Multimodal vectorizer modules (e.g., `multi2vec-clip`) create embeddings that represent combined concepts.                                                                                                                                                                          |
| **Multiple vector embeddings**                   | The capability to store multiple, distinct named vectors for a single data object. This allows representing different aspects or using embeddings from different models for the same object (e.g., one vector for content, one for title).                                                                                                                                                                                          |
| **Multi-vectors**                                | Multi-vector embeddings, also known as multi-vectors, represent a single object with multiple vectors, i.e. a 2-dimensional matrix.                                                                                                                                                                                                                                                                                                 |
| **NearText**                                     | A search operator that takes text input, uses the configured Vectorizer module to dynamically generate a query vector, and then performs a vector similarity search based on that vector.                                                                                                                                                                                                                                           |
| **Property**                                     | All classes have properties. E.g., the class Company might have the property _name_. In Weaviate, properties can be recognized because they always have a lowercase first character.                                                                                                                                                                                                                                                |
| **Quantization**                                 | Vector compression techniques (like Product Quantization 'PQ' or Binary Quantization 'BQ') used to reduce the memory footprint of vector embeddings, potentially trading some precision for significant storage and performance gains.                                                                                                                                                                                              |
| **Reranker**                                     | An AI model integrated with Weaviate (often via a module like `reranker-cohere`) that takes the initial list of search results and re-orders them based on a secondary relevance calculation, often improving the quality of the top results.                                                                                                                                                                                       |
| **Replication**                                  | The process of creating copies (replicas) of data shards across different nodes in a Weaviate cluster to ensure data durability and high availability in case of node failures. (Part of Clustering).                                                                                                                                                                                                                               |
| **Schema**                                       | In Weaviate, a schema is used to define the types of data you will be adding and querying. You can learn more about it [here](../starter-guides/managing-collections.md).                                                                                                                                                                                                                                                           |
| **Sharding**                                     | The process of splitting a Class's data and index horizontally across multiple nodes (shards) in a Weaviate cluster. This allows the dataset size and workload to scale beyond the capacity of a single node. (Part of Clustering).                                                                                                                                                                                                 |
| **Vector index**                                 | A data storage mechanism where data is stored as vectors (long arrays of numbers, also seen as coordinates in a high dimensional space), allowing for context-based search.                                                                                                                                                                                                                                                         |
| **Vectorizer**                                   | A module within Weaviate (e.g., `text2vec-openai`, `multi2vec-clip`) responsible for automatically converting specified data properties into vector embeddings using an underlying Embedding model, either during data import or at query time (e.g., for `nearText`).                                                                                                                                                              |
| **WCS**                                          | Weaviate Cloud Service. The former name for Weaviate's managed cloud offering. Now known as Weaviate Cloud (WCD).                                                                                                                                                                                                                                                                                                                   |
| **[Weaviate Cloud (WCD)](../cloud/overview.md)** | WCD is our SaaS for providing cloud instances of Weaviate.                                                                                                                                                                                                                                                                                                                                                                          |
| **Weaviate Cluster**                             | A managed Weaviate cluster.                                                                                                                                                                                                                                                                                                                                                                                                         |

```mdx-code-block
</APITable>
```

## 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`.
