# Managing Amazon OpenSearch Serverless collections
A *collection* in Amazon OpenSearch Serverless is a logical grouping of one or more indexes that represent an analytics workload. OpenSearch Serverless automatically manages and tunes the collection, requiring minimal manual input.
**Topics**
+ [Configuring permissions for collections](serverless-collection-permissions.md)
+ [Automatic semantic enrichment for Serverless](serverless-semantic-enrichment.md)
+ [Creating collections](serverless-create.md)
+ [Accessing OpenSearch Dashboards](serverless-dashboards.md)
+ [Viewing collections](serverless-list.md)
+ [Deleting collections](serverless-delete.md)
# Configuring permissions for collections
OpenSearch Serverless uses the following AWS Identity and Access Management (IAM) permissions for creating and managing collections. You can specify IAM conditions to restrict users to specific collections.
+ `aoss:CreateCollection` – Create a collection.
+ `aoss:ListCollections` – List collections in the current account.
+ `aoss:BatchGetCollection` – Get details about one or more collections.
+ `aoss:UpdateCollection` – Modify a collection.
+ `aoss:DeleteCollection` – Delete a collection.
The following sample identity-based access policy provides the minimum permissions necessary for a user to manage a single collection named `Logs`:
```
[
{
"Sid":"Allows managing logs collections",
"Effect":"Allow",
"Action":[
"aoss:CreateCollection",
"aoss:ListCollections",
"aoss:BatchGetCollection",
"aoss:UpdateCollection",
"aoss:DeleteCollection",
"aoss:CreateAccessPolicy",
"aoss:CreateSecurityPolicy"
],
"Resource":"*",
"Condition":{
"StringEquals":{
"aoss:collection":"Logs"
}
}
}
]
```
`aoss:CreateAccessPolicy` and `aoss:CreateSecurityPolicy` are included because encryption, network, and data access policies are required in order for a collection to function properly. For more information, see [Identity and Access Management for Amazon OpenSearch Serverless](security-iam-serverless.md).
**Note**
If you're creating the first collection in your account, you also need the `iam:CreateServiceLinkedRole` permission. For more information, see [Using service-linked roles to create OpenSearch Serverless collections](serverless-service-linked-roles.md).
# Automatic semantic enrichment for Serverless
## Introduction
The automatic semantic enrichment feature can help improve search relevance by up to 20% over lexical search. Automatic semantic enrichment eliminates the undifferentiated heavy lifting of managing your own ML (machine learning) model infrastructure and integration with the search engine. The feature is available for all three serverless collection types: Search, Time Series, and Vector.
## What is semantic search
Traditional search engines rely on word-to-word matching (referred to as lexical search) to find results for queries. Although this works well for specific queries such as television model numbers, it struggles with more abstract searches. For example, when searching for "shoes for the beach," a lexical search merely matches individual words "shoes," "beach," "for," and "the" in catalog items, potentially missing relevant products like "water-resistant sandals" or "surf footwear" that don't contain the exact search terms.
Semantic search returns query results that incorporate not just keyword matching, but the intent and contextual meaning of the user's search. For example, if a user searches for "how to treat a headache," a semantic search system might return the following results:
+ Migraine remedies
+ Pain management techniques
+ Over-the-counter pain relievers
## Model details and performance benchmark
While this feature handles the technical complexities behind the scenes without exposing the underlying model, we provide transparency through a brief model description and benchmark results to help you make informed decisions about feature adoption in your critical workloads.
Automatic semantic enrichment uses a service-managed, pre-trained sparse model that works effectively without requiring custom fine-tuning. The model analyzes the fields you specify, expanding them into sparse vectors based on learned associations from diverse training data. The expanded terms and their significance weights are stored in native Lucene index format for efficient retrieval. We’ve optimized this process using [document-only mode,](https://docs.opensearch.org/docs/latest/vector-search/ai-search/neural-sparse-with-pipelines/#step-1a-choose-the-search-mode) where encoding happens only during data ingestion. Search queries are merely tokenized rather than processed through the sparse model, making the solution both cost-effective and performant.
Our performance validation during feature development used the [MS MARCO](https://huggingface.co/datasets/BeIR/msmarco) passage retrieval dataset, featuring passages averaging 334 characters. For relevance scoring, we measured average Normalized Discounted Cumulative Gain (NDCG) for the first 10 search results (ndcg@10) on the [BEIR](https://github.com/beir-cellar/beir) benchmark for English content and average ndcg@10 on MIRACL for multilingual content. We assessed latency through client-side, 90th-percentile (p90) measurements and search response p90 [took values.](https://github.com/beir-cellar/beir) These benchmarks provide baseline performance indicators for both search relevance and response times. Here are the key benchmark numbers -
+ English language - Relevance improvement of 20% over lexical search. It also lowered P90 search latency by 7.7% over lexical search (BM25 is 26 ms, and automatic semantic enrichment is 24 ms).
+ Multi-lingual - Relevance improvement of 105% over lexical search, whereas P90 search latency increased by 38.4% over lexical search (BM25 is 26 ms, and automatic semantic enrichment is 36 ms).
Given the unique nature of each workload, we encourage you to evaluate this feature in your development environment using your own benchmarking criteria before making implementation decisions.
## Languages Supported
The feature supports English. In addition, the model also supports Arabic, Bengali, Chinese, Finnish, French, Hindi, Indonesian, Japanese, Korean, Persian, Russian, Spanish, Swahili, and Telugu.
## Set up an automatic semantic enrichment index for serverless collections
Setting up an index with automatic semantic enrichment enabled for your text fields is easy, and you can manage it through the console, APIs, and CloudFormation templates during new index creation. To enable it for an existing index, you need to recreate the index with automatic semantic enrichment enabled for text fields.
Console experience - The AWS console allows you to easily create an index with automatic semantic enrichment fields. Once you select a collection, you will find the create index button at the top of the console. Once you click the create index button, you will find options to define automatic semantic enrichment fields. In one index, you can have combinations of automatic semantic enrichment for English and multilingual, as well as lexical fields.
![\[alt text not found\]](http://docs.aws.amazon.com/opensearch-service/latest/developerguide/images/ase-console-exp-serverless.png)
API experience - To create an automatic semantic enrichment index using the AWS Command Line Interface (AWS CLI), use the create-index command:
```
aws opensearchserverless create-index \
--id [collection_id] \
--index-name [index_name] \
--index-schema [index_body] \
```
In the following example index-schema, the *title\$1semantic *field has a field type set to *text* and has parameter *semantic\$1enrichment *set to status *ENABLED*. Setting the *semantic\$1enrichment* parameter enables automatic semantic enrichment on the *title\$1semantic* field. You can use the *language\$1options* field to specify either *english* or *multi-lingual*.
```
aws opensearchserverless create-index \
--id XXXXXXXXX \
--index-name 'product-catalog' \
--index-schema '{
"mappings": {
"properties": {
"product_id": {
"type": "keyword"
},
"title_semantic": {
"type": "text",
"semantic_enrichment": {
"status": "ENABLED",
"language_options": "english"
}
},
"title_non_semantic": {
"type": "text"
}
}
}
}'
```
To describe the created index, use the following command:
```
aws opensearchserverless get-index \
--id [collection_id] \
--index-name [index_name] \
```
You can also use CloudFormation templates (Type:AWS::OpenSearchServerless::CollectionIndex) to create semantic search during collection provisioning as well as after the collection is created.
## Data ingestion and search
Once you've created an index with automatic semantic enrichment enabled, the feature works automatically during data ingestion process, no additional configuration required.
Data ingestion: When you add documents to your index, the system automatically:
+ Analyzes the text fields you designated for semantic enrichment
+ Generates semantic encodings using OpenSearch Service managed sparse model
+ Stores these enriched representations alongside your original data
This process uses OpenSearch's built-in ML connectors and ingest pipelines, which are created and managed automatically behind the scenes.
Search: The semantic enrichment data is already indexed, so queries run efficiently without invoking the ML model again. This means you get improved search relevance with no additional search latency overhead.
## Configuring permissions for automatic semantic enrichment
Before creating an automated semantic enrichment index, you need to configure the required permissions. This section explains the permissions needed and how to set them up.
### IAM policy permissions
Use the following AWS Identity and Access Management (IAM) policy to grant the necessary permissions for working with automatic semantic enrichment:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AutomaticSemanticEnrichmentPermissions",
"Effect": "Allow",
"Action": [
"aoss:CreateIndex",
"aoss:GetIndex",
"aoss:UpdateIndex",
"aoss:DeleteIndex",
"aoss:APIAccessAll"
],
"Resource": "*"
}
]
}
```
------
**Key permissions**
+ The `aoss:*Index` permissions enable index management
+ The `aoss:APIAccessAll` permission allows OpenSearch API operations
+ To restrict permissions to a specific collection, replace `"Resource": "*"` with the collection's ARN
### Configure data access permissions
To set up an index for automatic semantic enrichment, you must have appropriate data access policies that grant permission to access index, pipeline, and model collection resources. For more information about data access policies, see [Data access control for Amazon OpenSearch Serverless](serverless-data-access.md). For the procedure to configure a data access policy, see [Creating data access policies (console)](serverless-data-access.md#serverless-data-access-console).
#### Data access permissions
```
[
{
"Description": "Create index permission",
"Rules": [
{
"ResourceType": "index",
"Resource": ["index/collection_name/*"],
"Permission": [
"aoss:CreateIndex",
"aoss:DescribeIndex",
"aoss:UpdateIndex",
"aoss:DeleteIndex"
]
}
],
"Principal": [
"arn:aws:iam::account_id:role/role_name"
]
},
{
"Description": "Create pipeline permission",
"Rules": [
{
"ResourceType": "collection",
"Resource": ["collection/collection_name"],
"Permission": [
"aoss:CreateCollectionItems",
"aoss:DescribeCollectionItems"
]
}
],
"Principal": [
"arn:aws:iam::account_id:role/role_name"
]
},
{
"Description": "Create model permission",
"Rules": [
{
"ResourceType": "model",
"Resource": ["model/collection_name/*"],
"Permission": ["aoss:CreateMLResource"]
}
],
"Principal": [
"arn:aws:iam::account_id:role/role_name"
]
},
]
```
#### Network access permissions
To allow service APIs to access private collections, you must configure network policies that permit the required access between the service API and the collection. For more information about network policies, see [Network access for Amazon OpenSearch Serverless](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-network.html) .
```
[
{
"Description":"Enable automatic semantic enrichment in a private collection",
"Rules":[
{
"ResourceType":"collection",
"Resource":[
"collection/collection_name"
]
}
],
"AllowFromPublic":false,
"SourceServices":[
"aoss.amazonaws.com"
],
}
]
```
**To configure network access permissions for a private collection**
1. Sign in to the OpenSearch Service console at [https://console.aws.amazon.com/aos/home](https://console.aws.amazon.com/aos/home).
1. In the left navigation, choose *Network policies*. Then do one of the following:
+ Choose an existing policy name and choose *Edit*
+ Choose *Create network policy* and configure the policy details
1. In the *Access type* area, choose *Private (recommended)*, and then select *AWS service private access*.
1. In the search field, choose *Service*, and then choose *aoss.amazonaws.com*.
1. In the *Resource type* area, select the *Enable access to OpenSearch endpoint* box.
1. For *Search collection(s), or input specific prefix term(s)*, in the search field, select *Collection Name*. Then enter or select the name of the collections to associate with the network policy.
1. Choose *Create* for a new network policy or *Update* for an existing network policy.
## Query Rewrites
Automatic semantic enrichment automatically converts your existing “match” queries to semantic search queries without requiring query modifications. If a match query is part of a compound query, the system traverses your query structure, finds match queries, and replaces them with neural sparse queries. Currently, the feature only supports replacing “match” queries, whether it’s a standalone query or part of a compound query. “multi\$1match” is not supported. In addition, the feature supports all compound queries to replace their nested match queries. Compound queries include: bool, boosting, constant\$1score, dis\$1max, function\$1score, and hybrid.
## Limitations of automatic semantic enrichment
Automatic semantic search is most effective when applied to small-to-medium sized fields containing natural language content, such as movie titles, product descriptions, reviews, and summaries. Although semantic search enhances relevance for most use cases, it might not be optimal for certain scenarios. Consider following limitations when deciding whether to implement automatic semantic enrichment for your specific use case.
+ Very long documents – The current sparse model processes only the first 8,192 tokens of each document for English. For multilingual documents, it’s 512 tokens. For lengthy articles, consider implementing document chunking to ensure complete content processing.
+ Log analysis workloads – Semantic enrichment significantly increases index size, which might be unnecessary for log analysis where exact matching typically suffices. The additional semantic context rarely improves log search effectiveness enough to justify the increased storage requirements.
+ Automatic semantic enrichment is not compatible with the Derived Source feature.
+ Throttling – Indexing inference requests are currently capped at 100 TPS for OpenSearch Serverless. This is a soft limit; reach out to AWS Support for higher limits.
## Pricing
OpenSearch Serverless bills automatic semantic enrichment based on OpenSearch Compute Units (OCUs) consumed during sparse vector generation at indexing time. You’re charged only for actual usage during indexing. You can monitor this consumption using the Amazon CloudWatch metric SemanticSearchOCU. For specific details about model token limits, volume throughput per OCU, and example of sample calculation, visit [ OpenSearch Service Pricing](https://aws.amazon.com/opensearch-service/pricing/).
# Creating collections
You can use the console or the AWS CLI to create a serverless collection. These steps cover how to create a *search* or *time series* collection. To create a *vector search* collection, see [Working with vector search collections](serverless-vector-search.md).
**Topics**
+ [Create a collection (console)](serverless-create-console.md)
+ [Create a collection (CLI)](serverless-create-cli.md)
# Create a collection (console)
Use the procedures in this section to create a collection by using the AWS Management Console. These steps cover how to create a *search* or *time series* collection. To create a *vector search* collection, see [Working with vector search collections](serverless-vector-search.md).
**Topics**
+ [Configure collection settings](#serverless-create-console-step-2)
+ [Configure additional search fields](#serverless-create-console-step-3)
## Configure collection settings
Use the following procedure configure information about your collection.
**To configure collection settings using the console**
1. Navigate to the Amazon OpenSearch Service console at [https://console.aws.amazon.com/aos/home/](https://console.aws.amazon.com/aos/home/).
1. Expand **Serverless** in the left navigation pane and choose **Collections**.
1. Choose **Create collection**.
1. Provide a name and description for the collection. The name must meet the following criteria:
+ Is unique to your account and AWS Region
+ Contains only lowercase letters a-z, the numbers 0–9, and the hyphen (-)
+ Contains between 3 and 32 characters
1. Choose a collection type:
+ **Time series** – Log analytics segment that focuses on analyzing large volumes of semi-structured, machine-generated data. At least 24 hours of data is stored on hot indexes, and the rest remains in warm storage.
+ **Search** – Full-text search that powers applications in your internal networks and internet-facing applications. All search data is stored in hot storage to ensure fast query response times.
**Note**
Choose this option if you are enabling automatic semantic search, as described in [Configure collection settings](#serverless-create-console-step-2).
+ **Vector search** – Semantic search on vector embeddings that simplifies vector data management. Powers machine learning (ML) augmented search experiences and generative AI applications such as chatbots, personal assistants, and fraud detection.
For more information, see [Choosing a collection type](serverless-overview.md#serverless-usecase).
1. For **Deployment type**, choose the redundancy setting for your collection. By default, each collection has redundancy, which means that the indexing and search OpenSearch Compute Units (OCUs) each have their own standby replicas in a different Availability Zone. For development and testing purposes, you can choose to disable redundancy, which reduces the number of OCUs in your collection to two. For more information, see [How it works](serverless-overview.md#serverless-process).
1. For **Security**, choose **Standard create**.
1. For **Encryption**, choose an AWS KMS key to encrypt your data with. OpenSearch Serverless notifies you if the collection name that you entered matches a pattern defined in an encryption policy. You can choose to keep this match or override it with unique encryption settings. For more information, see [Encryption in Amazon OpenSearch Serverless](serverless-encryption.md).
1. For **Network access settings**, configure network access for the collection.
+ For **Access type**, select public or private.
If you choose private, specify which VPC endpoints and AWS services can access the collection.
+ **VPC endpoints for access** – Specify one or more VPC endpoints to allow access through. To create a VPC endpoint, see [Data plane access through AWS PrivateLink](serverless-vpc.md).
+ **AWS service private access** – Select one or more supported services to allow access to.
+ For **Resource type**, select whether users can access the collection through its *OpenSearch* endpoint (to make API calls through cURL, Postman, and so on), through the *OpenSearch Dashboards* endpoint (to work with visualizations and make API calls through the console), or both.
**Note**
AWS service private access applies only to the OpenSearch endpoint, not to the OpenSearch Dashboards endpoint.
OpenSearch Serverless notifies you if the collection name that you entered matches a pattern defined in a network policy. You can choose to keep this match or override it with custom network settings. For more information, see [Network access for Amazon OpenSearch Serverless](serverless-network.md).
1. (Optional) Add one or more tags to the collection. For more information, see [Tagging Amazon OpenSearch Serverless collections](tag-collection.md).
1. Choose **Next**.
## Configure additional search fields
The options you see on page two of the create collection workflow depend on the type of collection you are creating. This section describes how to configure additional search fields for each collection type. This section also describes how to configure automatic semantic enrichment. Skip any section that doesn't apply to your collection type.
**Topics**
+ [Configure automatic semantic enrichment](#serverless-create-console-step-3-semantic-enrichment-fields)
+ [Configure time series search fields](#serverless-create-console-step-3-time-series-fields)
+ [Configure lexical search fields](#serverless-create-console-step-3-lexical-fields)
+ [Configure vector search fields](#serverless-create-console-step-3-vector-search-fields)
### Configure automatic semantic enrichment
When you create or edit a collection, you can configure automatic semantic enrichment, which simplifies semantic search implementation and capabilities in Amazon OpenSearch Service. Semantic search returns query results that incorporate not just keyword matching, but the intent and contextual meaning of the user's search. For more information, see [Automatic semantic enrichment for Serverless](serverless-semantic-enrichment.md).
**To configure automatic semantic enrichment**
1. In the **Index details** section, for **Index name**, specify a name.
1. In the **Automatic semantic enrichment fields** section, choose **Add semantic search field**.
1. In the **Input field name for semantic enrichment** field, enter the name of a field that you want to enrich.
1. **Data type** is **Text**. You can't change this.
1. For **Language**, choose either **English** or **Multilingual**.
1. Choose **Add field**.
1. After you finish configuring optional fields for your collection, choose **Next**. Review your changes and choose **Submit** to create the collection.
### Configure time series search fields
The options in the **Time series search fields** section pertain to time series data and data streams. For more information about these subjects, see [Managing time-series data in Amazon OpenSearch Service with data streams](data-streams.md).
**To configure time series search fields**
1. In the **Time series search fields** section, choose **Add time series field**.
1. For **Field name**, enter a name.
1. For **Data type**, choose a type from the list.
1. Choose **Add field**
1. After you finish configuring optional fields for your collection, choose **Next**. Review your changes and choose **Submit** to create the collection.
### Configure lexical search fields
Lexical search seeks an exact match between a search query and indexed terms or keywords.
**To configure lexical search fields**
1. In the **Lexical search fields** section, choose **Add search field**.
1. For **Field name**, enter a name.
1. For **Data type**, choose a type from the list.
1. Choose **Add field**
1. After you finish configuring optional fields for your collection, choose **Next**. Review your changes and choose **Submit** to create the collection.
### Configure vector search fields
**To configure vector search fields**
1. In the **Vector fields** section, choose **Add vector field**.
1. For **Field name**, enter a name.
1. For **Engine**, choose a type from the list.
1. Enter the number of dimensions.
1. For **Distance Metric**, choose a type from the list.
1. After you finish configuring optional fields for your collection, choose **Next**.
1. Review your changes and choose **Submit** to create the collection.
# Create a collection (CLI)
Use the procedures in this section to create an OpenSearch Serverless collection using the AWS CLI.
**Topics**
+ [Before you begin](#serverless-create-cli-before-you-begin)
+ [Creating a collection](#serverless-create-cli-creating)
+ [Creating a collection with an automatic semantic enrichment index](#serverless-create-cli-automatic-semantic-enrichment)
## Before you begin
Before you create a collection using the AWS CLI, use the following procedure to create required policies for the collection.
**Note**
In each of the following procedures, when you specify a name for a collection, the name must meet the following criteria:
Is unique to your account and AWS Region
Contains only lowercase letters a-z, the numbers 0–9, and the hyphen (-)
Contains between 3 and 32 characters
**To create required policies for a collection**
1. Open the AWS CLI and run the following command to create an [encryption policy](serverless-encryption.md) with a resource pattern that matches the intended name of the collection.
```
&aws opensearchserverless create-security-policy \
--name policy name \
--type encryption --policy "{\"Rules\":[{\"ResourceType\":\"collection\",\"Resource\":[\"collection\/collection name\"]}],\"AWSOwnedKey\":true}"
```
For example, if you plan to name your collection *logs-application*, you might create an encryption policy like this:
```
&aws opensearchserverless create-security-policy \
--name logs-policy \
--type encryption --policy "{\"Rules\":[{\"ResourceType\":\"collection\",\"Resource\":[\"collection\/logs-application\"]}],\"AWSOwnedKey\":true}"
```
If you plan to use the policy for additional collections, you can make the rule more broad, such as `collection/logs*` or `collection/*`.
1. Run the following command to configure network settings for the collection using a [network policy](serverless-network.md). You can create network policies after you create a collection, but we recommend doing it beforehand.
```
&aws opensearchserverless create-security-policy \
--name policy name \
--type network --policy "[{\"Description\":\"description\",\"Rules\":[{\"ResourceType\":\"dashboard\",\"Resource\":[\"collection\/collection name\"]},{\"ResourceType\":\"collection\",\"Resource\":[\"collection\/collection name\"]}],\"AllowFromPublic\":true}]"
```
Using the previous *logs-application* example, you might create the following network policy:
```
&aws opensearchserverless create-security-policy \
--name logs-policy \
--type network --policy "[{\"Description\":\"Public access for logs collection\",\"Rules\":[{\"ResourceType\":\"dashboard\",\"Resource\":[\"collection\/logs-application\"]},{\"ResourceType\":\"collection\",\"Resource\":[\"collection\/logs-application\"]}],\"AllowFromPublic\":true}]"
```
## Creating a collection
The following procedure uses the [CreateCollection](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_CreateCollection.html) API action to create a collection of type `SEARCH` or `TIMESERIES`. If you don't specify a collection type in the request, it defaults to `TIMESERIES`. For more information about these types, see [Choosing a collection type](serverless-overview.md#serverless-usecase). To create a *vector search* collection, see [Working with vector search collections](serverless-vector-search.md).
If your collection is encrypted with an AWS owned key, the `kmsKeyArn` is `auto` rather than an ARN.
**Important**
After you create a collection, you won't be able to access it unless it matches a data access policy. For more information, see [Data access control for Amazon OpenSearch Serverless](serverless-data-access.md).
**To create a collection**
1. Verify that you created required policies described in [Before you begin](#serverless-create-cli-before-you-begin).
1. Run the following command. For `type` specify either `SEARCH` or `TIMESERIES`.
```
&aws opensearchserverless create-collection --name "collection name" --type collection type --description "description"
```
## Creating a collection with an automatic semantic enrichment index
Use the following procedure to create a new OpenSearch Serverless collection with an index that is configured for [automatic semantic enrichment](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-semantic-enrichment.html). The procedure uses the OpenSearch Serverless [CreateIndex](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_CreateIndex.html) API action.
**To create a new collection with an index configured for automatic semantic enrichment**
Run the following command to create the collection and an index.
```
&aws opensearchserverless create-index \
--region Region ID \
--id collection name --index-name index name \
--index-schema \
'mapping in json'
```
Here's an example.
```
&aws opensearchserverless create-index \
--region us-east-1 \
--id conversation_history --index-name conversation_history_index \
--index-schema \
'{
"mappings": {
"properties": {
"age": {
"type": "integer"
},
"name": {
"type": "keyword"
},
"user_description": {
"type": "text"
},
"conversation_history": {
"type": "text",
"semantic_enrichment": {
"status": "ENABLED",
// Specifies the sparse tokenizer for processing multi-lingual text
"language_option": "MULTI-LINGUAL",
// If embedding_field is provided, the semantic embedding field will be set to the given name rather than original field name + "_embedding"
"embedding_field": "conversation_history_user_defined"
}
},
"book_title": {
"type": "text",
"semantic_enrichment": {
// No embedding_field is provided, so the semantic embedding field is set to "book_title_embedding"
"status": "ENABLED",
"language_option": "ENGLISH"
}
},
"abstract": {
"type": "text",
"semantic_enrichment": {
// If no language_option is provided, it will be set to English.
// No embedding_field is provided, so the semantic embedding field is set to "abstract_embedding"
"status": "ENABLED"
}
}
}
}
}'
```
# Accessing OpenSearch Dashboards
After you create a collection with the AWS Management Console, you can navigate to the collection's OpenSearch Dashboards URL. You can find the Dashboards URL by choosing **Collections** in the left navigation pane and selecting the collection to open its details page. The URL takes the format `https://dashboards.us-east-1.aoss.amazonaws.com/_login/?collectionId=07tjusf2h91cunochc`. Once you navigate to the URL, you'll automatically log into Dashboards.
If you already have the OpenSearch Dashboards URL available but aren't on the AWS Management Console, calling the Dashboards URL from the browser will redirect to the console. Once you enter your AWS credentials, you'll automatically log in to Dashboards. For information about accessing collections for SAML, see [Accessing OpenSearch Dashboards with SAML](serverless-saml.md#serverless-saml-dashboards).
The OpenSearch Dashboards console timeout is one hour and isn't configurable.
**Note**
On May 10, 2023, OpenSearch introduced a common global endpoint for OpenSearch Dashboards. You can now navigate to OpenSearch Dashboards in the browser with a URL that takes the format `https://dashboards.us-east-1.aoss.amazonaws.com/_login/?collectionId=07tjusf2h91cunochc`. To ensure backward compatibility, we'll continue to support the existing collection specific OpenSearch Dashboards endpoints with the format `https://07tjusf2h91cunochc.us-east-1.aoss.amazonaws.com/_dashboards`.
# Viewing collections
You can view the existing collections in your AWS account on the **Collections** tab of the Amazon OpenSearch Service console.
To list collections along with their IDs, send a [ListCollections](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_ListCollections.html) request.
```
&aws opensearchserverless list-collections
```
**Sample response**
```
{
"collectionSummaries":[
{
"arn":"arn:aws:aoss:us-east-1:123456789012:collection/07tjusf2h91cunochc",
"id":"07tjusf2h91cunochc",
"name":"my-collection",
"status":"CREATING"
}
]
}
```
To limit the search results, use collection filters. This request filters the response to collections in the `ACTIVE` state:
```
&aws opensearchserverless list-collections --collection-filters '{ "status": "ACTIVE" }'
```
To get more detailed information about one or more collections, including the OpenSearch endpoint and the OpenSearch Dashboards endpoint, send a [BatchGetCollection](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_BatchGetCollection.html) request:
```
&aws opensearchserverless batch-get-collection --ids "07tjusf2h91cunochc" "1iu5usc4rame"
```
**Note**
You can include `--names` or `--ids` in the request, but not both.
**Sample response**
```
{
"collectionDetails":[
{
"id": "07tjusf2h91cunochc",
"name": "my-collection",
"status": "ACTIVE",
"type": "SEARCH",
"description": "",
"arn": "arn:aws:aoss:us-east-1:123456789012:collection/07tjusf2h91cunochc",
"kmsKeyArn": "arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"createdDate": 1667446262828,
"lastModifiedDate": 1667446300769,
"collectionEndpoint": "https://07tjusf2h91cunochc.us-east-1.aoss.amazonaws.com",
"dashboardEndpoint": "https://07tjusf2h91cunochc.us-east-1.aoss.amazonaws.com/_dashboards"
},
{
"id": "178ukvtg3i82dvopdid",
"name": "another-collection",
"status": "ACTIVE",
"type": "TIMESERIES",
"description": "",
"arn": "arn:aws:aoss:us-east-1:123456789012:collection/178ukvtg3i82dvopdid",
"kmsKeyArn": "arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"createdDate": 1667446262828,
"lastModifiedDate": 1667446300769,
"collectionEndpoint": "https://178ukvtg3i82dvopdid.us-east-1.aoss.amazonaws.com",
"dashboardEndpoint": "https://178ukvtg3i82dvopdid.us-east-1.aoss.amazonaws.com/_dashboards"
}
],
"collectionErrorDetails":[]
}
```
# Deleting collections
Deleting a collection deletes all data and indexes in the collection. You can't recover collections after you delete them.
**To delete a collection using the console**
1. From the **Collections** panel of the Amazon OpenSearch Service console, select the collection you want to delete.
1. Choose **Delete** and confirm deletion.
To delete a collection using the AWS CLI, send a [DeleteCollection](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_DeleteCollection.html) request:
```
&aws opensearchserverless delete-collection --id 07tjusf2h91cunochc
```
**Sample response**
```
{
"deleteCollectionDetail":{
"id":"07tjusf2h91cunochc",
"name":"my-collection",
"status":"DELETING"
}
}
```