Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Apprendimento automatico per Amazon OpenSearch Service
ML Commons è un OpenSearch plug-in che fornisce una serie di algoritmi di machine learning (ML) comuni tramite il trasporto e le chiamate API REST. Queste chiamate scelgono i nodi e le risorse giusti per ogni richiesta ML e monitorano le attività ML per garantire l'operatività. Ciò consente di sfruttare gli algoritmi ML open source esistenti e di ridurre lo sforzo richiesto per sviluppare nuove funzionalità di machine learning. Per ulteriori informazioni sul plug-in, consulta [Machine learning nella documentazione](https://opensearch.org/docs/latest/ml-commons-plugin/index/). OpenSearch Questo capitolo spiega come utilizzare il plug-in con Amazon OpenSearch Service.
**Topics**
+ [Connettori Amazon OpenSearch Service ML per Servizi AWS](ml-amazon-connector.md)
+ [Connettori Amazon OpenSearch Service ML per piattaforme di terze parti](ml-external-connector.md)
+ [Utilizzo CloudFormation per configurare l'inferenza remota per la ricerca semantica](cfn-template.md)
+ [Impostazioni ML Commons non supportate](#sm)
+ [OpenSearch Modelli di framework di flussi di servizio](ml-workflow-framework.md)
# Connettori Amazon OpenSearch Service ML per Servizi AWS
Quando utilizzi connettori di apprendimento automatico (ML) di Amazon OpenSearch Service con un altro Servizio AWS, devi configurare un ruolo IAM per connettere in modo sicuro OpenSearch Service a quel servizio. Servizi AWS che puoi configurare un connettore per includere Amazon SageMaker AI e Amazon Bedrock. In questo tutorial, spieghiamo come creare un connettore da OpenSearch Service a SageMaker Runtime. Per ulteriori informazioni sui connettori, consulta [Connettori supportati](https://opensearch.org/docs/latest/ml-commons-plugin/remote-models/connectors/#supported-connectors).
**Topics**
+ [Prerequisiti](#connector-sagemaker-prereq)
+ [Crea un connettore di servizio OpenSearch](#connector-sagemaker-create)
## Prerequisiti
Per creare un connettore, devi disporre di un endpoint di dominio Amazon SageMaker AI e di un ruolo IAM che garantisca l'accesso OpenSearch al servizio.
### Configura un dominio Amazon SageMaker AI
Consulta [Deploy a Model in Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-deployment.html) nella *Amazon SageMaker AI Developer Guide* per implementare il tuo modello di machine learning. Prendi nota dell'URL dell'endpoint per il tuo modello, di cui hai bisogno per creare un connettore AI.
### Creazione di un ruolo IAM
Imposta un ruolo IAM per delegare le autorizzazioni SageMaker di Runtime a Service. OpenSearch Per creare un nuovo ruolo, consulta [Creating an IAM role (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html#roles-creatingrole-user-console) nella *IAM User Guide*. Facoltativamente, puoi utilizzare un ruolo esistente purché abbia lo stesso set di privilegi. Se crei un nuovo ruolo invece di usare un ruolo AWS gestito, sostituiscilo `opensearch-sagemaker-role` in questo tutorial con il nome del tuo ruolo.
1. Allega la seguente policy IAM gestita al tuo nuovo ruolo per consentire a OpenSearch Service di accedere al tuo endpoint SageMaker AI. Per allegare una policy a un ruolo, consulta [Aggiungere i permessi di identità IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpointAsync",
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
1. Segui le istruzioni riportate in [Modifica della politica di fiducia di un ruolo](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-managingrole_edit-trust-policy) per modificare la relazione di trust del ruolo. Nella seguente politica, sostituiscila *service-principal* con uno dei seguenti principali di servizio per OpenSearch Service o OpenSearch Serverless:
**Per Service OpenSearch **
`opensearchservice.amazonaws.com`
**Per OpenSearch Serverless**
`ml.opensearchservice.amazonaws.com`
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sts:AssumeRole"
],
"Effect": "Allow",
"Principal": {
"Service": [
"ml.opensearchservice.amazonaws.com"
]
}
}
]
}
```
------
Ti consigliamo di utilizzare i tasti `aws:SourceAccount` e `aws:SourceArn` condition per limitare l'accesso a un dominio specifico. `SourceAccount`è l' Account AWS ID che appartiene al proprietario del dominio e il `SourceArn` è l'ARN del dominio. Ad esempio, puoi aggiungere il seguente blocco di condizioni alla politica di fiducia:
```
"Condition": {
"StringEquals": {
"aws:SourceAccount": "account-id"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:es:region:account-id:domain/domain-name"
}
}
```
### Configurazione delle autorizzazioni
Per creare il connettore, è necessaria l'autorizzazione per passare il ruolo IAM a OpenSearch Service. Devi inoltre disporre dell'accesso all'operazione `es:ESHttpPost`. Per concedere entrambe queste autorizzazioni, collega la policy seguente al ruolo IAM le cui credenziali vengono utilizzate per firmare la richiesta:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/opensearch-sagemaker-role"
},
{
"Effect": "Allow",
"Action": "es:ESHttpPost",
"Resource": "arn:aws:es:us-east-1:111122223333:domain/domain-name/*"
}
]
}
```
------
Se il tuo utente o ruolo non dispone `iam:PassRole` delle autorizzazioni per trasferire il ruolo, potresti riscontrare un errore di autorizzazione quando tenti di registrare un repository nel passaggio successivo.
### Mappa il ruolo ML nelle OpenSearch dashboard (se utilizzi un controllo di accesso granulare)
Il controllo granulare degli accessi introduce un passaggio aggiuntivo per la configurazione di un connettore. Anche se si utilizza l'autenticazione di base HTTP per tutti gli altri scopi, è necessario mappare il ruolo `ml_full_access` al ruolo IAM che dispone delle autorizzazioni `iam:PassRole` per inviare `opensearch-sagemaker-role`.
1. Vai al plug-in OpenSearch Dashboards per il tuo dominio di servizio. OpenSearch Puoi trovare l'endpoint Dashboards nella dashboard del tuo dominio nella OpenSearch console di servizio.
1. Dal menu principale scegli **Sicurezza**, **Ruoli e seleziona il ruolo** **ml\$1full\$1access**.
1. Scegliere **Utenti mappati**, **Gestisci mappatura**.
1. In **Ruoli di backend**, aggiungi l'ARN del ruolo che ha le autorizzazioni da passare. `opensearch-sagemaker-role`
```
arn:aws:iam::account-id:role/role-name
```
1. Selezionare **Mappa** e confermare che l'utente o il ruolo venga visualizzato in **Utenti mappati**.
## Crea un connettore di servizio OpenSearch
Per creare un connettore, invia una `POST` richiesta all'endpoint del dominio di OpenSearch servizio. Puoi usare curl, il client Python di esempio, Postman o un altro metodo per inviare una richiesta firmata. Nota che non puoi usare una `POST` richiesta nella console Kibana. La richiesta ha il seguente formato:
```
POST domain-endpoint/_plugins/_ml/connectors/_create
{
"name": "sagemaker: embedding",
"description": "Test connector for Sagemaker embedding model",
"version": 1,
"protocol": "aws_sigv4",
"credential": {
"roleArn": "arn:aws:iam::account-id:role/opensearch-sagemaker-role"
},
"parameters": {
"region": "region",
"service_name": "sagemaker"
},
"actions": [
{
"action_type": "predict",
"method": "POST",
"headers": {
"content-type": "application/json"
},
"url": "https://runtime.sagemaker.region.amazonaws.com/endpoints/endpoint-id/invocations",
"request_body": "{ \"inputs\": { \"question\": \"${parameters.question}\", \"context\": \"${parameters.context}\" } }"
}
]
}
```
Se il dominio risiede all'interno di un cloud privato virtuale (VPC), il computer deve essere connesso al VPC affinché la richiesta crei correttamente il connettore AI. L'accesso a un VPC varia in base alla configurazione di rete, ma di solito comporta la connessione a una VPN o a una rete aziendale. Per verificare di poter accedere al dominio del OpenSearch servizio, accedi a `https://your-vpc-domain.region.es.amazonaws.com` In un browser Web e verifica di ricevere la risposta JSON predefinita.
### Client Python di esempio
Il client Python è più semplice da automatizzare rispetto a una richiesta HTTP e ha una migliore riusabilità. Per creare il connettore AI con il client Python, salva il seguente codice di esempio in un file Python. Il client richiede i pacchetti [AWS SDK per Python (Boto3)[https://requests.readthedocs.io/en/latest/](https://requests.readthedocs.io/en/latest/)](https://aws.amazon.com/sdk-for-python/), e [https://pypi.org/project/requests-aws4auth/](https://pypi.org/project/requests-aws4auth/).
```
import boto3
import requests
from requests_aws4auth import AWS4Auth
host = 'domain-endpoint/'
region = 'region'
service = 'es'
credentials = boto3.Session().get_credentials()
awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token)
# Register repository
path = '_plugins/_ml/connectors/_create'
url = host + path
payload = {
"name": "sagemaker: embedding",
"description": "Test connector for Sagemaker embedding model",
"version": 1,
"protocol": "aws_sigv4",
"credential": {
"roleArn": "arn:aws:iam::account-id:role/opensearch-sagemaker-role"
},
"parameters": {
"region": "region",
"service_name": "sagemaker"
},
"actions": [
{
"action_type": "predict",
"method": "POST",
"headers": {
"content-type": "application/json"
},
"url": "https://runtime.sagemaker.region.amazonaws.com/endpoints/endpoint-id/invocations",
"request_body": "{ \"inputs\": { \"question\": \"${parameters.question}\", \"context\": \"${parameters.context}\" } }"
}
]
}
headers = {"Content-Type": "application/json"}
r = requests.post(url, auth=awsauth, json=payload, headers=headers)
print(r.status_code)
print(r.text)
```
# Connettori Amazon OpenSearch Service ML per piattaforme di terze parti
In questo tutorial, spieghiamo come creare un connettore da OpenSearch Service a Cohere. Per ulteriori informazioni sui connettori, consulta [Connettori supportati](https://opensearch.org/docs/latest/ml-commons-plugin/remote-models/connectors/#supported-connectors).
Quando utilizzi un connettore di apprendimento automatico (ML) di Amazon OpenSearch Service con un modello remoto esterno, devi memorizzare le tue credenziali di autorizzazione specifiche in Gestione dei segreti AWS. Potrebbe trattarsi di una chiave API o di una combinazione di nome utente e password. Ciò significa che devi anche creare un ruolo IAM che consenta l'accesso al OpenSearch servizio per la lettura da Secrets Manager.
**Topics**
+ [Prerequisiti](#connector-external-prereq)
+ [Crea un connettore di servizio OpenSearch](#connector-external-create)
## Prerequisiti
Per creare un connettore per Cohere o per qualsiasi provider esterno con OpenSearch Service, devi disporre di un ruolo IAM che conceda l'accesso al OpenSearch Servizio Gestione dei segreti AWS, a cui archiviare le tue credenziali. È inoltre necessario memorizzare le credenziali in Secrets Manager.
### Creazione di un ruolo IAM
Imposta un ruolo IAM per delegare le autorizzazioni di Secrets Manager a OpenSearch Service. Puoi anche utilizzare il ruolo esistente`SecretManagerReadWrite`. Per creare un nuovo ruolo, consulta [Creating an IAM role (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html#roles-creatingrole-user-console) nella *IAM User Guide*. Se crei un nuovo ruolo invece di utilizzare un ruolo AWS gestito, `opensearch-secretmanager-role` sostituiscilo in questo tutorial con il nome del tuo ruolo.
1. Allega la seguente policy IAM gestita al tuo nuovo ruolo per consentire a OpenSearch Service di accedere ai tuoi valori di Secrets Manager. Per allegare una policy a un ruolo, consulta [Aggiungere autorizzazioni di identità IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"secretsmanager:GetSecretValue"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
1. Segui le istruzioni riportate in [Modifica della politica di fiducia di un ruolo](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-managingrole_edit-trust-policy) per modificare la relazione di trust del ruolo. Nella seguente politica, sostituiscila *service-principal* con uno dei seguenti principali di servizio per OpenSearch Service o OpenSearch Serverless:
**Per Service OpenSearch **
`opensearchservice.amazonaws.com`
**Per OpenSearch Serverless**
`ml.opensearchservice.amazonaws.com`
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sts:AssumeRole"
],
"Effect": "Allow",
"Principal": {
"Service": [
"service-principle"
]
}
}
]
}
```
------
Ti consigliamo di utilizzare i tasti `aws:SourceAccount` e `aws:SourceArn` condition per limitare l'accesso a un dominio specifico. `SourceAccount`è l' Account AWS ID che appartiene al proprietario del dominio e il `SourceArn` è l'ARN del dominio. Ad esempio, puoi aggiungere il seguente blocco di condizioni alla politica di fiducia:
```
"Condition": {
"StringEquals": {
"aws:SourceAccount": "account-id"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:es:region:account-id:domain/domain-name"
}
}
```
### Configurazione delle autorizzazioni
Per creare il connettore, è necessaria l'autorizzazione per passare il ruolo IAM a OpenSearch Service. Devi inoltre disporre dell'accesso all'operazione `es:ESHttpPost`. Per concedere entrambe queste autorizzazioni, collega la policy seguente al ruolo IAM le cui credenziali vengono utilizzate per firmare la richiesta:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/opensearch-secretmanager-role"
},
{
"Effect": "Allow",
"Action": "es:ESHttpPost",
"Resource": "arn:aws:es:us-east-1:111122223333:domain/domain-name/*"
}
]
}
```
------
Se il tuo utente o ruolo non dispone `iam:PassRole` delle autorizzazioni per trasferire il ruolo, potresti riscontrare un errore di autorizzazione quando tenti di registrare un repository nel passaggio successivo.
### Configurare Gestione dei segreti AWS
Per memorizzare le credenziali di autorizzazione in Secrets Manager, consulta [Creare un Gestione dei segreti AWS segreto](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) nella *Guida per l'Gestione dei segreti AWS utente*.
Dopo che Secrets Manager ha accettato la coppia chiave-valore come segreta, riceverai un ARN con il formato:. `arn:aws:secretsmanager:us-west-2:123456789012:secret:MySecret-a1b2c3` Tieni traccia di questo ARN, così come lo usi, e della tua chiave quando crei un connettore nel passaggio successivo.
### Mappa il ruolo ML nelle OpenSearch dashboard (se utilizzi un controllo di accesso granulare)
Il controllo granulare degli accessi introduce un passaggio aggiuntivo per la configurazione di un connettore. Anche se si utilizza l'autenticazione di base HTTP per tutti gli altri scopi, è necessario mappare il ruolo `ml_full_access` al ruolo IAM che dispone delle autorizzazioni `iam:PassRole` per inviare `opensearch-sagemaker-role`.
1. Vai al plug-in OpenSearch Dashboards per il tuo dominio di servizio. OpenSearch Puoi trovare l'endpoint Dashboards nella dashboard del tuo dominio nella OpenSearch console di servizio.
1. Dal menu principale scegli **Sicurezza**, **Ruoli e seleziona il ruolo** **ml\$1full\$1access**.
1. Scegliere **Utenti mappati**, **Gestisci mappatura**.
1. In **Ruoli di backend**, aggiungi l'ARN del ruolo che ha le autorizzazioni da passare. `opensearch-sagemaker-role`
```
arn:aws:iam::account-id:role/role-name
```
1. Selezionare **Mappa** e confermare che l'utente o il ruolo venga visualizzato in **Utenti mappati**.
## Crea un connettore di servizio OpenSearch
Per creare un connettore, invia una `POST` richiesta all'endpoint del dominio di OpenSearch servizio. Puoi usare curl, il client Python di esempio, Postman o un altro metodo per inviare una richiesta firmata. Nota che non puoi usare una `POST` richiesta nella console Kibana. La richiesta ha il seguente formato:
```
POST domain-endpoint/_plugins/_ml/connectors/_create
{
"name": "Cohere Connector: embedding",
"description": "The connector to cohere embedding model",
"version": 1,
"protocol": "http",
"credential": {
"secretArn": "arn:aws:secretsmanager:region:account-id:secret:cohere-key-id",
"roleArn": "arn:aws:iam::account-id:role/opensearch-secretmanager-role"
},
"actions": [
{
"action_type": "predict",
"method": "POST",
"url": "https://api.cohere.ai/v1/embed",
"headers": {
"Authorization": "Bearer ${credential.secretArn.cohere-key-used-in-secrets-manager}"
},
"request_body": "{ \"texts\": ${parameters.texts}, \"truncate\": \"END\" }"
}
]
}
```
Il corpo della richiesta per questa richiesta è diverso da quello di una richiesta di connettore open source in due modi. All'interno del `credential` campo, si passa l'ARN per il ruolo IAM che consente a OpenSearch Service di leggere da Secrets Manager, insieme all'ARN per il segreto what. Nel `headers` campo, si fa riferimento al segreto utilizzando la chiave segreta e al fatto che proviene da un ARN.
Se il dominio risiede all'interno di un cloud privato virtuale (VPC), il computer deve essere connesso al VPC affinché la richiesta crei correttamente il connettore AI. L'accesso a un VPC varia in base alla configurazione di rete, ma di solito comporta la connessione a una VPN o a una rete aziendale. Per verificare di poter accedere al dominio del OpenSearch servizio, accedi a `https://your-vpc-domain.region.es.amazonaws.com` In un browser Web e verifica di ricevere la risposta JSON predefinita.
### Client Python di esempio
Il client Python è più semplice da automatizzare rispetto a una richiesta HTTP e ha una migliore riusabilità. Per creare il connettore AI con il client Python, salva il seguente codice di esempio in un file Python. Il client richiede i pacchetti [AWS SDK per Python (Boto3)[https://requests.readthedocs.io/en/latest/](https://requests.readthedocs.io/en/latest/)](https://aws.amazon.com/sdk-for-python/), e [https://pypi.org/project/requests-aws4auth/](https://pypi.org/project/requests-aws4auth/).
```
import boto3
import requests
from requests_aws4auth import AWS4Auth
host = 'domain-endpoint/'
region = 'region'
service = 'es'
credentials = boto3.Session().get_credentials()
awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token)
path = '_plugins/_ml/connectors/_create'
url = host + path
payload = {
"name": "Cohere Connector: embedding",
"description": "The connector to cohere embedding model",
"version": 1,
"protocol": "http",
"credential": {
"secretArn": "arn:aws:secretsmanager:region:account-id:secret:cohere-key-id",
"roleArn": "arn:aws:iam::account-id:role/opensearch-secretmanager-role"
},
"actions": [
{
"action_type": "predict",
"method": "POST",
"url": "https://api.cohere.ai/v1/embed",
"headers": {
"Authorization": "Bearer ${credential.secretArn.cohere-key-used-in-secrets-manager}"
},
"request_body": "{ \"texts\": ${parameters.texts}, \"truncate\": \"END\" }"
}
]
}
headers = {"Content-Type": "application/json"}
r = requests.post(url, auth=awsauth, json=payload, headers=headers)
print(r.status_code)
print(r.text)
```
# Utilizzo CloudFormation per configurare l'inferenza remota per la ricerca semantica
A partire dalla OpenSearch versione 2.9, puoi utilizzare l'inferenza remota con la [ricerca semantica per ospitare i tuoi modelli](https://opensearch.org/docs/latest/search-plugins/semantic-search/) di machine learning (ML). [L'inferenza remota utilizza il plug-in ML Commons.](https://opensearch.org/docs/latest/ml-commons-plugin/index/)
Con l'inferenza remota, puoi ospitare le inferenze dei tuoi modelli in remoto su servizi ML, come Amazon AI SageMaker e Amazon Bedrock, e collegarli ad Amazon OpenSearch Service con connettori ML.
Per facilitare la configurazione dell'inferenza remota, Amazon OpenSearch Service fornisce un [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)modello nella console. CloudFormation è un ambiente Servizio AWS in cui è possibile effettuare il provisioning AWS e gestire risorse di terze parti trattando l'infrastruttura come codice.
Il OpenSearch CloudFormation modello automatizza il processo di provisioning del modello per te, in modo che tu possa creare facilmente un modello nel tuo dominio di OpenSearch servizio e quindi utilizzare l'ID del modello per importare dati ed eseguire query di ricerca neurali.
Quando utilizzi codificatori neurali sparsi con la versione 2.12 e successive del OpenSearch servizio, ti consigliamo di utilizzare il modello tokenizer localmente anziché distribuirlo in remoto. [Per ulteriori informazioni, consulta i modelli di codifica Sparse nella documentazione.](https://opensearch.org/docs/latest/ml-commons-plugin/pretrained-models/#sparse-encoding-models) OpenSearch
**Topics**
+ [Modelli disponibili CloudFormation](#cfn-template-list)
+ [Prerequisiti](#cfn-template-prereq)
+ [Modelli Amazon Bedrock](cfn-template-bedrock.md)
+ [Configurazione di Agentic Search con Bedrock Claude](cfn-template-agentic-search.md)
+ [Modelli di integrazione con server MCP](cfn-template-mcp-server.md)
+ [SageMaker Modelli Amazon](cfn-template-sm.md)
+ [Inferenza remota per modelli di evidenziazione semantica](#cfn-template-semantic-highlighting)
## Modelli disponibili CloudFormation
I seguenti modelli di AWS CloudFormation machine learning (ML) sono disponibili per l'uso:[Modelli Amazon Bedrock](cfn-template-bedrock.md)
**Integrazione con Amazon Titan Text Embeddings**
Si connette ai modelli ML ospitati di Amazon Bedrock, elimina la necessità di implementare modelli separati e utilizza endpoint Amazon Bedrock predeterminati. Per ulteriori informazioni, consulta [Amazon Titan Text Embeddings](https://docs.aws.amazon.com/bedrock/latest/userguide/titan-embedding-models.html) nella Guida per l'utente di *Amazon Bedrock*.
**Integrazione con Cohere Embed**
Fornisce l'accesso ai modelli Cohere Embed ed è ottimizzato per flussi di lavoro di elaborazione del testo specifici. *Per ulteriori informazioni, consulta [Incorpora](https://docs.cohere.com/docs/cohere-embed) nel sito Web di Cohere docs.*
**Incorporamenti multimodali di Amazon Titan**
Supporta l'incorporamento di testo e immagini e abilita funzionalità di ricerca multimodale. Per ulteriori informazioni, consulta [Amazon Titan Multimodal Embeddings nella](https://docs.aws.amazon.com/bedrock/latest/userguide/titan-multiemb-models.html) *Amazon* Bedrock User Guide.[Modelli di integrazione con server MCP](cfn-template-mcp-server.md)
**Integrazione con server MCP**
Implementa un [Amazon Bedrock AgentCore Runtime](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/what-is-bedrock-agentcore.html), fornisce un endpoint agente, gestisce l'autenticazione in entrata e in uscita e supporta l'autenticazione aziendale. OAuth [SageMaker Modelli Amazon](cfn-template-sm.md)
**Integrazione con modelli di incorporamento del testo tramite Amazon SageMaker**
Implementa modelli di incorporamento di testo in Amazon SageMaker Runtime, crea ruoli IAM per l'accesso agli artefatti del modello e stabilisce connettori ML per la ricerca semantica.
**Integrazione con Sparse Encoders tramite SageMaker**
Imposta modelli di codifica sparsi per la ricerca neurale, crea AWS Lambda funzioni per la gestione dei connettori e restituisce il modello per l'uso immediato. IDs
## Prerequisiti
Per utilizzare un CloudFormation modello con OpenSearch Service, completa i seguenti prerequisiti.
### Configura un dominio di OpenSearch servizio
Prima di poter utilizzare un CloudFormation modello, devi configurare un [dominio Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/osis-get-started.html) con la versione 2.9 o successiva e il controllo granulare degli accessi abilitato. [Crea un ruolo OpenSearch di backend del servizio](fgac.md#fgac-roles) per autorizzare il plug-in ML Commons a creare il connettore per te.
Il CloudFormation modello crea per te un ruolo Lambda IAM con il nome predefinito`LambdaInvokeOpenSearchMLCommonsRole`, che puoi sostituire se desideri scegliere un nome diverso. Dopo che il modello ha creato questo ruolo IAM, devi autorizzare la funzione Lambda a chiamare il tuo dominio di OpenSearch servizio. A tale scopo, [associa il ruolo](fgac.md#fgac-mapping) denominato `ml_full_access` al tuo ruolo OpenSearch di backend Service con i seguenti passaggi:
1. Vai al plug-in OpenSearch Dashboards per il tuo dominio di OpenSearch servizio. Puoi trovare l'endpoint Dashboards nella dashboard del tuo dominio nella OpenSearch console di servizio.
1. Dal menu principale scegli **Sicurezza**, **Ruoli e seleziona il ruolo** **ml\$1full\$1access**.
1. Scegliere **Utenti mappati**, **Gestisci mappatura**.
1. In **Ruoli di backend**, aggiungi l'ARN del ruolo Lambda che richiede l'autorizzazione per chiamare il tuo dominio.
```
arn:aws:iam::account-id:role/role-name
```
1. Selezionare **Mappa** e confermare che l'utente o il ruolo venga visualizzato in **Utenti mappati**.
Dopo aver mappato il ruolo, vai alla configurazione di sicurezza del tuo dominio e aggiungi il ruolo Lambda IAM alla OpenSearch tua policy di accesso al servizio.
### Abilita le autorizzazioni sul tuo Account AWS
Account AWS Devi avere l'autorizzazione per accedere CloudFormation e Lambda, insieme a qualsiasi modello Servizio AWS tu scelga per il tuo modello, che sia Runtime SageMaker o Amazon Bedrock.
Se utilizzi Amazon Bedrock, devi anche registrare il tuo modello. Consulta [Model access](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html) nella *Amazon Bedrock User Guide* per registrare il tuo modello.
Se utilizzi il tuo bucket Amazon S3 per fornire artefatti del modello, devi aggiungere il ruolo CloudFormation IAM alla tua policy di accesso S3. Per ulteriori informazioni, consulta [Aggiunta e rimozione di autorizzazioni per identità IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) nella *Guida per l’utente di IAM *.
# Modelli Amazon Bedrock
I CloudFormation modelli Amazon Bedrock forniscono le AWS risorse necessarie per creare connettori tra OpenSearch Service e Amazon Bedrock.
Innanzitutto, il modello crea un ruolo IAM che consente alla futura funzione Lambda di accedere al dominio del OpenSearch servizio. Il modello crea quindi la funzione Lambda, che consente al dominio di creare un connettore utilizzando il plug-in ML Commons. Dopo che OpenSearch Service ha creato il connettore, la configurazione dell'inferenza remota è terminata e puoi eseguire ricerche semantiche utilizzando le operazioni dell'API Amazon Bedrock.
**Nota**
Poiché Amazon Bedrock ospita i propri modelli di machine learning, non è necessario distribuire un modello in Runtime. SageMaker Al contrario, il modello utilizza un endpoint predeterminato per Amazon Bedrock e salta le fasi di fornitura degli endpoint.
**Per utilizzare il modello Amazon Bedrock CloudFormation**
1. Apri la [console Amazon OpenSearch Service](https://console.aws.amazon.com/aos/home ).
1. Nel riquadro di navigazione a sinistra, scegli **Integrazioni.**
1. **Nella sezione **Integrazione con il modello Amazon Titan Text Embeddings tramite Amazon Bedrock**, scegli **Configura dominio, Configura dominio** pubblico.**
1. Segui le istruzioni per configurare il tuo modello.
**Nota**
OpenSearch Il servizio fornisce anche un modello separato per configurare un dominio Amazon VPC. Se utilizzi questo modello, devi fornire l'ID Amazon VPC per la funzione Lambda.
Inoltre, OpenSearch Service fornisce i seguenti modelli Amazon Bedrock per connettersi al modello Cohere e al modello Amazon Titan Multimodal Embeddings:
+ `Integration with Cohere Embed through Amazon Bedrock`
+ `Integrate with Amazon Bedrock Titan Multi-modal`
# Configurazione di Agentic Search con Bedrock Claude
Agentic search sfrutta agenti autonomi per eseguire ricerche complesse per conto dell'utente, comprendendo le intenzioni degli utenti, orchestrando gli strumenti giusti, generando query ottimizzate e fornendo riepiloghi trasparenti delle loro decisioni attraverso un'interfaccia in linguaggio naturale. Questi agenti si basano su modelli di ragionamento, come Bedrock Claude.
Segui i passaggi seguenti per aprire ed eseguire un CloudFormation modello che configuri automaticamente i modelli Bedrock Claude per la ricerca agentica e come configurare e creare i tuoi agenti nel plug-in AI Search Flows su Dashboards. OpenSearch
## Attivazione di Bedrock Claude Access
1. **Prerequisito:** se il tuo dominio utilizza un controllo degli accessi dettagliato, esegui il mapping `arn:aws:iam::your-account-id:role/LambdaInvokeOpenSearchMLCommonsRole` come ruolo di backend al ruolo prima di eseguire il modello. `ml_full_access` Questo ruolo IAM verrà creato automaticamente CloudFormation se non esiste già. Per ulteriori informazioni su come configurare la mappatura, consulta[Mappa il ruolo ML nelle OpenSearch dashboard (se utilizzi un controllo di accesso granulare)](ml-external-connector.md#connector-external-fgac).
1. Apri la console Amazon OpenSearch Service a [https://console.aws.amazon.com/aos/casa](https://console.aws.amazon.com/aos/home).
1. Nella barra di navigazione a sinistra, scegli **Integrazioni.**
1. **In **Integrazione con Bedrock Claude for Agentic Search**, scegli Configura dominio.** Assicurati che il tuo dominio sia nella versione 3.3 o successiva.
1. Nel CloudFormation modello, inserisci l'endpoint OpenSearch del dominio di servizio e seleziona un modello. I campi rimanenti sono facoltativi o precompilati. Fai clic su **Crea stack** e attendi il completamento del provisioning.
1. Dalla console di Amazon OpenSearch Service, seleziona **Domini** e seleziona il tuo dominio. Fai clic sull'**URL delle OpenSearch dashboard** per accedere OpenSearch alle dashboard.
## Creazione di agenti ed esecuzione di Agentic Search
1. Da OpenSearch Dashboards, apri il menu sul lato sinistro. Seleziona **OpenSearch Plugin** > **AI Search Flows** per accedere al plugin.
1. **Nella pagina **Flussi di lavoro**, seleziona la scheda **Nuovo flusso di lavoro** e, nella scheda **Agentic Search**, fai clic su Crea.**
1. **Fornisci un nome univoco per la configurazione di ricerca e fai clic su Crea.**
1. In **Configura agente**, fai clic su **Crea nuovo agente**. **Seleziona il modello Bedrock Claude appena creato, quindi fai clic su Crea agente.** Se il pulsante è disabilitato, seleziona **Impostazioni avanzate** > Interfaccia **LLM e assicurati che sia selezionata un'interfaccia** valida. **Tutti i modelli CloudFormation saranno modelli Bedrock Claude, quindi puoi selezionare **Bedrock Claude**, se non lo è già, quindi fare clic su Crea agente.**
1. In **Test flow, prova** a eseguire ricerche agentiche. **Fornisci una query di ricerca in linguaggio naturale e fai clic su Cerca.**
Per la documentazione completa del plug-in AI Search Flows, consulta [Configuring Agentic Search](https://docs.opensearch.org/latest/vector-search/ai-search/building-agentic-search-flows/) nella documentazione. OpenSearch
Per ulteriori informazioni su come funziona Agentic Search, consulta [Agentic](https://opensearch.org/docs/latest/vector-search/ai-search/agentic-search/) Search nella documentazione. OpenSearch
# Modelli di integrazione con server MCP
Con i modelli di server Model Context Protocol (MCP), puoi implementare un server MCP OpenSearch ospitato su Amazon Bedrock AgentCore, riducendo la complessità di integrazione tra agenti e strumenti di intelligenza artificiale. OpenSearch Per ulteriori informazioni, consulta [Cos'è Amazon Bedrock AgentCore](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/what-is-bedrock-agentcore.html)? .
## Caratteristiche del modello
Questo modello include le seguenti funzionalità chiave per la distribuzione e la gestione del server MCP.
**Implementazione gestita del server MCP**
Esegue la distribuzione **opensearch-mcp-server-py**utilizzando Amazon Bedrock AgentCore Runtime e fornisce un endpoint agente che invia tramite proxy le richieste al server MCP sottostante. Per ulteriori informazioni, consulta on. [opensearch-mcp-server-py*GitHub*](https://github.com/opensearch-project/opensearch-mcp-server-py)
**Autenticazione e sicurezza**
Gestisce sia l'autenticazione in entrata (dagli utenti al server MCP) che l'autenticazione in uscita (dal server MCP a OpenSearch) e supporta OAuth l'autenticazione aziendale.
**Nota**
Il modello di server MCP è disponibile solo nei seguenti casi: Regioni AWS
Stati Uniti orientali (Virginia settentrionale)
Stati Uniti occidentali (Oregon)
Europa (Francoforte)
Asia Pacifico (Sydney)
## Per utilizzare il modello di server MCP
Segui questi passaggi per distribuire il modello di server MCP e collegarlo al tuo OpenSearch dominio.
1. Apri la [console Amazon OpenSearch Service](https://console.aws.amazon.com//aos/home ).
1. Nel riquadro di navigazione a sinistra, scegli **Integrazioni.**
1. Individua il **modello di integrazione del server MCP**.
1. Scegli **Configura dominio**. Quindi, inserisci l'endpoint OpenSearch del tuo dominio.
Il modello crea un AgentCore Runtime e i seguenti componenti, se non vengono specificati i parametri opzionali corrispondenti:
+ Repository Amazon ECR
+ Un pool di utenti Amazon Cognito come autorizzatore OAuth
+ Un ruolo di esecuzione utilizzato dal Runtime AgentCore
Dopo aver completato questa procedura, è necessario seguire questi passaggi successivi alla creazione:
1. **Per Amazon OpenSearch Service**: associa il tuo ruolo di esecuzione ARN a un ruolo di OpenSearch backend per controllare l'accesso al tuo dominio.
**Per Amazon OpenSearch Serverless**: crea una policy di accesso ai dati che consenta al tuo ruolo esecutivo di accedere alla tua raccolta.
1. Ottieni un token di OAuth accesso dal tuo autorizzatore. Quindi usa questo token per accedere al server MCP all'URL elencato nell'output CloudFormation dello stack.
Per ulteriori informazioni, consulta [Azioni politiche per Serverless OpenSearch](security-iam-serverless.md#security-iam-serverless-id-based-policies-actions).
## Integrazione con agenti AI
Dopo l'implementazione, è possibile integrare il server MCP con qualsiasi agente compatibile con MCP. Per ulteriori informazioni, consulta [Richiamare il server MCP distribuito](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-mcp.html#runtime-mcp-invoke-server) nella *Amazon Bedrock* Developer Guide.
**Integrazione con gli sviluppatori**
È possibile aggiungere l'endpoint del server MCP alla configurazione dell'agente. Puoi anche usarlo con Amazon Q Developer CLI, agenti personalizzati o altri agenti compatibili con MCP.
**Distribuzione aziendale**
Gli agenti ospitati centralmente possono connettersi a più servizi OpenSearch utilizzando un unico componente. Questo agente supporta tutti i sistemi di autenticazione aziendali OAuth ed è scalabile per supportare più utenti e casi d'uso.
### Esempio di utilizzo del framework Strands Agents
```
import os
import requests
from strands import Agent
from strands.tools.mcp import MCPClient
from mcp.client.streamable_http import streamablehttp_client
def get_bearer_token(discovery_url: str, client_id: str, client_secret: str):
response = requests.get(discovery_url)
discovery_data = response.json()
token_endpoint = discovery_data['token_endpoint']
data = {
'grant_type': 'client_credentials',
'client_id': client_id,
'client_secret': client_secret
}
headers = {
'Content-Type': 'application/x-www-form-urlencoded'
}
response = requests.post(token_endpoint, data=data, headers=headers)
token_data = response.json()
return token_data['access_token']
if __name__ == "__main__":
discovery_url = os.environ["DISCOVERY_URL"]
client_id = os.environ["CLIENT_ID"]
client_secret = os.environ["CLIENT_SECRET"]
mcp_url = os.environ["MCP_URL"]
bearer_token = get_bearer_token(discovery_url, client_id, client_secret)
opensearch_mcp_client = MCPClient(lambda: streamablehttp_client(mcp_url, {
"authorization": f"Bearer {bearer_token}",
"Content-Type": "application/json"
}))
with opensearch_mcp_client:
tools = opensearch_mcp_client.list_tools_sync()
agent = Agent(tools=tools)
agent("list indices")
```
*Per ulteriori informazioni, consulta [Hosting OpenSearch MCP Server with Amazon Bedrock AgentCore sul OpenSearch sito](https://opensearch.org/blog/hosting-opensearch-mcp-server-with-amazon-bedrock-agentcore/) Web.*
# SageMaker Modelli Amazon
I SageMaker CloudFormation modelli Amazon definiscono più AWS risorse per configurare il plug-in neurale e la ricerca semantica per te.
Inizia utilizzando il modello **Integrazione con modelli di incorporamento del testo tramite Amazon** per distribuire un SageMaker modello di incorporamento di testo in SageMaker Runtime come server. Se non fornisci un endpoint modello, CloudFormation crea un ruolo IAM che consente a SageMaker Runtime di scaricare gli artefatti del modello da Amazon S3 e distribuirli sul server. Se fornisci un endpoint, CloudFormation crea un ruolo IAM che consente alla funzione Lambda di accedere al dominio OpenSearch del servizio o, se il ruolo esiste già, aggiorna e riutilizza il ruolo. L'endpoint serve il modello remoto utilizzato per il connettore ML con il plug-in ML Commons.
Quindi, utilizza il SageMaker modello **Integration with Sparse Encoders through Amazon** per creare una funzione Lambda che consenta al tuo dominio di configurare connettori di inferenza remoti. Dopo aver creato il connettore in OpenSearch Service, l'inferenza remota può eseguire una ricerca semantica utilizzando il modello remoto in Runtime. SageMaker Il modello ti restituisce l'ID del modello nel tuo dominio in modo che tu possa iniziare la ricerca.
**Per utilizzare i CloudFormation modelli Amazon SageMaker AI**
1. Apri la [console Amazon OpenSearch Service](https://console.aws.amazon.com//aos/home ).
1. Nel riquadro di navigazione a sinistra, scegli **Integrazioni.**
1. In ciascuno dei modelli Amazon SageMaker AI, scegli **Configura dominio**, **Configura dominio pubblico**.
1. Segui le istruzioni nella CloudFormation console per effettuare il provisioning dello stack e configurare un modello.
**Nota**
OpenSearch Il servizio fornisce anche un modello separato per configurare il dominio VPC. Se utilizzi questo modello, devi fornire l'ID VPC per la funzione Lambda.
## Inferenza remota per modelli di evidenziazione semantica
L'evidenziazione semantica è una funzionalità di ricerca avanzata che migliora la pertinenza dei risultati analizzando il significato e il contesto delle query anziché basarsi esclusivamente sulle corrispondenze esatte delle parole chiave. Questa funzionalità utilizza modelli di apprendimento automatico per valutare la somiglianza semantica tra le query di ricerca e il contenuto dei documenti, identificando ed evidenziando le frasi o i passaggi più rilevanti dal punto di vista contestuale all'interno dei documenti. A differenza dei metodi di evidenziazione tradizionali che si concentrano sulle corrispondenze esatte dei termini, l'evidenziazione semantica sfrutta i modelli di intelligenza artificiale per valutare ogni frase utilizzando informazioni contestuali provenienti sia dalla query che dal testo circostante, consentendole di far emergere informazioni pertinenti anche quando non sono presenti termini di ricerca esatti nei passaggi evidenziati. Questo approccio è particolarmente utile per le implementazioni di ricerca basate sull'intelligenza artificiale in cui gli utenti danno la priorità al significato semantico rispetto alla corrispondenza letterale delle parole, consentendo agli amministratori della ricerca di offrire esperienze di ricerca più intelligenti e contestualmente consapevoli che evidenziano intervalli di contenuti significativi anziché semplici occorrenze di parole chiave. [Per ulteriori informazioni](https://docs.opensearch.org/latest/tutorials/vector-search/semantic-highlighting-tutorial/), consulta Utilizzo dell'evidenziazione semantica.
Utilizza la procedura seguente: apri ed esegui un CloudFormation modello che configura automaticamente i SageMaker modelli Amazon per l'evidenziazione semantica.
**Per utilizzare il modello di evidenziazione semantica CloudFormation**
1. Apri la console Amazon OpenSearch Service a [https://console.aws.amazon.com/aos/casa](https://console.aws.amazon.com/aos/home ).
1. Nella barra di navigazione a sinistra, scegli **Integrazioni.**
1. In **Abilita l'evidenziazione semantica tramite l' SageMakerintegrazione di Amazon**, scegli **Configura dominio**, **Configura dominio pubblico**.
1. Segui le istruzioni per configurare il tuo modello.
**Nota**
OpenSearch Il servizio fornisce anche un modello separato per configurare il dominio VPC. Se utilizzi questo modello, devi fornire l'ID VPC per la funzione Lambda.
## Impostazioni ML Commons non supportate
Amazon OpenSearch Service non supporta l'uso delle seguenti impostazioni ML Commons:
+ `plugins.ml_commons.allow_registering_model_via_url`
+ `plugins.ml_commons.allow_registering_model_via_local_file`
**Importante**
Nei *cluster di produzione*, non disabilitare l'impostazione del cluster `plugins.ml_commons.only_run_on_ml_node` (non impostarla `false` su). L'opzione per disabilitare questa protezione serve a facilitare lo sviluppo, ma i cluster di produzione dovrebbero utilizzare i connettori. Per ulteriori informazioni, consulta [Connettori Amazon OpenSearch Service ML per Servizi AWS](ml-amazon-connector.md).
Per ulteriori informazioni sulle impostazioni del cluster ML Commons, vedere Impostazioni del cluster [ML](https://opensearch.org/docs/latest/ml-commons-plugin/cluster-settings/) Commons.
# OpenSearch Modelli di framework di flussi di servizio
I modelli di framework di flusso di Amazon OpenSearch Service consentono di automatizzare attività complesse di configurazione e preelaborazione del OpenSearch servizio fornendo modelli per casi d'uso comuni. Ad esempio, puoi utilizzare i modelli di Flow Framework per automatizzare le attività di configurazione dell'apprendimento automatico. I modelli di framework di flusso di Amazon OpenSearch Service forniscono una descrizione compatta del processo di configurazione in un documento JSON o YAML. Questi modelli descrivono configurazioni automatizzate di flussi di lavoro per chat conversazionali o generazione di query, connettori AI, strumenti, agenti e altri componenti che preparano OpenSearch Service per l'uso in backend per modelli generativi.
I modelli di framework di flusso di Amazon OpenSearch Service possono essere personalizzati per soddisfare esigenze specifiche. Per vedere un esempio di modello di framework di flusso personalizzato, consulta [flow-framework](https://github.com/opensearch-project/flow-framework/blob/main/sample-templates/deploy-bedrock-claude-model.json). [Per i modelli forniti dal OpenSearch servizio, vedere workflow-templates.](https://opensearch.org/docs/2.13/automating-configurations/workflow-templates/) Per una documentazione completa, che include passaggi dettagliati, un riferimento all'API e un riferimento a tutte le impostazioni disponibili, vedi [Automating Configuration](https://github.com/opensearch-project/flow-framework/blob/main/sample-templates/deploy-bedrock-claude-model.json) nella documentazione open source. OpenSearch
**Nota**
Flow-framework non supporta il filtraggio dei ruoli di backend per Service 2.17. OpenSearch
# Creazione di connettori ML in Service OpenSearch
I modelli di framework di flusso di Amazon OpenSearch Service consentono di configurare e installare connettori ML utilizzando l'API create connector offerta in ml-commons. Puoi utilizzare i connettori ML per connettere OpenSearch Service ad altri AWS servizi o piattaforme di terze parti. Per ulteriori informazioni su questo argomento, consulta [Creazione di connettori per piattaforme ML di terze parti](https://opensearch.org/docs/2.13/ml-commons-plugin/remote-models/connectors/). L'API del framework di flusso di Amazon OpenSearch Service consente di automatizzare le attività di configurazione e preelaborazione del OpenSearch servizio e può essere utilizzata per creare connettori ML.
Prima di poter creare un connettore in OpenSearch Service, devi fare quanto segue:
+ Crea un dominio Amazon SageMaker AI.
+ Crea un ruolo IAM.
+ Configura l'autorizzazione al pass role.
+ Mappa i ruoli flow-framework e ml-commons nelle dashboard. OpenSearch
Per ulteriori informazioni su come configurare i connettori ML per AWS i servizi, consulta i [connettori ML OpenSearch di Amazon Service per AWS i servizi](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/ml-amazon-connector.html#connector-sagemaker-prereq). Per ulteriori informazioni sull'utilizzo dei connettori OpenSearch Service ML con piattaforme di terze parti, consulta [Connettori Amazon OpenSearch Service ML per piattaforme di terze parti](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/ml-amazon-connector.html#connector-sagemaker-prereq).
## Creazione di un connettore tramite un servizio flow-framework
Per creare un modello di flow-framework con connettore, è necessario inviare una `POST` richiesta all'endpoint del dominio di servizio. OpenSearch Puoi usare cURL, un client Python di esempio, Postman o un altro metodo per inviare una richiesta firmata. La `POST` richiesta ha il seguente formato:
```
POST /_plugins/_flow_framework/workflow
{
"name": "Deploy Claude Model",
"description": "Deploy a model using a connector to Claude",
"use_case": "PROVISION",
"version": {
"template": "1.0.0",
"compatibility": [
"2.12.0",
"3.0.0"
]
},
"workflows": {
"provision": {
"nodes": [
{
"id": "create_claude_connector",
"type": "create_connector",
"user_inputs": {
"name": "Claude Instant Runtime Connector",
"version": "1",
"protocol": "aws_sigv4",
"description": "The connector to Bedrock service for Claude model",
"actions": [
{
"headers": {
"x-amz-content-sha256": "required",
"content-type": "application/json"
},
"method": "POST",
"request_body": "{ \"prompt\":\"${parameters.prompt}\", \"max_tokens_to_sample\":${parameters.max_tokens_to_sample}, \"temperature\":${parameters.temperature}, \"anthropic_version\":\"${parameters.anthropic_version}\" }",
"action_type": "predict",
"url": "https://bedrock-runtime.us-west-2.amazonaws.com/model/anthropic.claude-instant-v1/invoke"
}
],
"credential": {
"roleArn": "arn:aws:iam::account-id:role/opensearch-secretmanager-role"
},
"parameters": {
"endpoint": "bedrock-runtime.us-west-2.amazonaws.com",
"content_type": "application/json",
"auth": "Sig_V4",
"max_tokens_to_sample": "8000",
"service_name": "bedrock",
"temperature": "0.0001",
"response_filter": "$.completion",
"region": "us-west-2",
"anthropic_version": "bedrock-2023-05-31"
}
}
}
]
}
}
}
```
Se il tuo dominio risiede in un cloud privato virtuale (Amazon VPC), devi essere connesso ad Amazon VPC affinché la richiesta crei correttamente il connettore AI. L'accesso a un Amazon VPC varia in base alla configurazione di rete, ma di solito comporta la connessione a una VPN o a una rete aziendale. Per verificare di poter accedere al dominio del OpenSearch servizio, accedi a `https://your-vpc-domain.region.es.amazonaws.com` In un browser Web e verifica di ricevere la risposta JSON predefinita. (*placeholder text*Sostituiscili con i tuoi valori.
### Client Python di esempio
Il client Python è più semplice da automatizzare rispetto a una `HTTP` richiesta e ha una migliore riutilizzabilità. Per creare il connettore AI con il client Python, salva il seguente codice di esempio in un file Python. [Il client richiede i pacchetti [AWS SDK for Python (Boto3), requests:HTTP for](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/ml-amazon-connector.html#connector-sagemaker-prereq)[Humans e requests-aws4auth 1.2.3](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/ml-amazon-connector.html#connector-sagemaker-prereq).](https://pypi.org/project/requests-aws4auth/)
```
import boto3
import requests
from requests_aws4auth import AWS4Auth
host = 'domain-endpoint/'
region = 'region'
service = 'es'
credentials = boto3.Session().get_credentials()
awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token)
path = '_plugins/_flow_framework/workflow'
url = host + path
payload = {
"name": "Deploy Claude Model",
"description": "Deploy a model using a connector to Claude",
"use_case": "PROVISION",
"version": {
"template": "1.0.0",
"compatibility": [
"2.12.0",
"3.0.0"
]
},
"workflows": {
"provision": {
"nodes": [
{
"id": "create_claude_connector",
"type": "create_connector",
"user_inputs": {
"name": "Claude Instant Runtime Connector",
"version": "1",
"protocol": "aws_sigv4",
"description": "The connector to Bedrock service for Claude model",
"actions": [
{
"headers": {
"x-amz-content-sha256": "required",
"content-type": "application/json"
},
"method": "POST",
"request_body": "{ \"prompt\":\"${parameters.prompt}\", \"max_tokens_to_sample\":${parameters.max_tokens_to_sample}, \"temperature\":${parameters.temperature}, \"anthropic_version\":\"${parameters.anthropic_version}\" }",
"action_type": "predict",
"url": "https://bedrock-runtime.us-west-2.amazonaws.com/model/anthropic.claude-instant-v1/invoke"
}
],
"credential": {
"roleArn": "arn:aws:iam::account-id:role/opensearch-secretmanager-role"
},
"parameters": {
"endpoint": "bedrock-runtime.us-west-2.amazonaws.com",
"content_type": "application/json",
"auth": "Sig_V4",
"max_tokens_to_sample": "8000",
"service_name": "bedrock",
"temperature": "0.0001",
"response_filter": "$.completion",
"region": "us-west-2",
"anthropic_version": "bedrock-2023-05-31"
}
}
}
]
}
}
}
headers = {"Content-Type": "application/json"}
r = requests.post(url, auth=awsauth, json=payload, headers=headers)
print(r.status_code)
print(r.text)
```
#### Modelli di workflow predefiniti
Amazon OpenSearch Service fornisce diversi modelli di flusso di lavoro per alcuni casi d'uso comuni di machine learning (ML). L'utilizzo di un modello semplifica le configurazioni complesse e fornisce molti valori predefiniti per casi d'uso come la ricerca semantica o conversazionale. Puoi specificare un modello di workflow quando chiami l'API Create Workflow.
+ Per utilizzare un modello di workflow fornito dal OpenSearch servizio, specifica il caso d'uso del modello come parametro di `use_case` query.
+ Per utilizzare un modello di workflow personalizzato, fornisci il modello completo nel corpo della richiesta. Per un esempio di modello personalizzato, vedi un esempio di modello JSON o un modello YAML di esempio.
#### Casi d'uso del modello
Questa tabella fornisce una panoramica dei diversi modelli disponibili, una descrizione dei modelli e i parametri richiesti.
| Caso d'uso del modello | Description | Parametri obbligatori |
| --- | --- | --- |
| `bedrock_titan_embedding_model_deploy` | Crea e distribuisce un modello di incorporamento Amazon Bedrock (per impostazione predefinita, `titan-embed-text-v1` | `create_connector.credential.roleArn` |
| `bedrock_titan_embedding_model_deploy` | Crea e distribuisce un modello di incorporamento multimodale Amazon Bedrock (per impostazione predefinita, `titan-embed-text-v1` | `create_connector.credential.roleArn` |
| `cohere_embedding_model_deploy` | Crea e distribuisce un modello di incorporamento Cohere (per impostazione predefinita, 3.0). embed-english-v | `create_connector.credential.roleArn`, `create_connector.credential.secretArn` |
| `cohere_chat_model_deploy` | Crea e distribuisce un modello di chat Cohere (per impostazione predefinita, Cohere Command). | `create_connector.credential.roleArn`, `create_connector.credential.secretArn` |
| `open_ai_embedding_model_deploy` | Crea e distribuisce un modello di incorporamento OpenAI (per impostazione predefinita text-embedding-ada, -002). | `create_connector.credential.roleArn`, `create_connector.credential.secretArn` |
| `openai_chat_model_deploy` | Crea e distribuisce un modello di chat OpenAI (per impostazione predefinita, gpt-3.5-turbo). | `create_connector.credential.roleArn`, `create_connector.credential.secretArn` |
| `semantic_search_with_cohere_embedding` | Configura la ricerca semantica e implementa un modello di incorporamento Cohere. È necessario fornire la chiave API per il modello Cohere. | `create_connector.credential.roleArn`, `create_connector.credential.secretArn` |
| `semantic_search_with_cohere_embedding_query_enricher` | Configura la ricerca semantica e implementa un modello di incorporamento Cohere. Aggiunge un processore di ricerca query\$1enricher che imposta un ID modello predefinito per le query neurali. È necessario fornire la chiave API per il modello Cohere. | `create_connector.credential.roleArn`, `create_connector.credential.secretArn` |
| `multimodal_search_with_bedrock_titan` | Implementa un modello multimodale Amazon Bedrock e configura una pipeline di ingestione con un processore text\$1image\$1embedding e un indice k-NN per la ricerca multimodale. Devi AWS fornire le tue credenziali. | `create_connector.credential.roleArn` |
**Nota**
Per tutti i modelli che richiedono un ARN segreto, l'impostazione predefinita prevede l'archiviazione del segreto con il nome chiave «key» in AWS Secrets Manager.
## Modelli predefiniti con modelli preaddestrati
Amazon OpenSearch Service offre due modelli di flusso di lavoro predefiniti aggiuntivi non disponibili nel servizio opensource OpenSearch .
| Caso d'uso del modello | Description |
| --- | --- |
| `semantic_search_with_local_model` | Configura la [ricerca semantica](https://opensearch.org/docs/2.14/search-plugins/semantic-search/) e distribuisce un modello preaddestrato (). `msmarco-distilbert-base-tas-b` Aggiunge un processore [https://opensearch.org/docs/2.14/search-plugins/search-pipelines/neural-query-enricher/](https://opensearch.org/docs/2.14/search-plugins/search-pipelines/neural-query-enricher/)di ricerca che imposta un ID modello predefinito per le query neurali e crea un indice k-NN collegato chiamato ''. my-nlp-index |
| `hybrid_search_with_local_model` | Configura la [ricerca ibrida](https://opensearch.org/docs/2.14/search-plugins/hybrid-search/) e implementa un modello preaddestrato (). `msmarco-distilbert-base-tas-b` Aggiunge un processore [https://opensearch.org/docs/2.14/search-plugins/search-pipelines/neural-query-enricher/](https://opensearch.org/docs/2.14/search-plugins/search-pipelines/neural-query-enricher/)di ricerca che imposta un ID modello predefinito per le query neurali e crea un indice k-NN collegato chiamato ''. my-nlp-index |
# Configurazione delle autorizzazioni
Se crei un nuovo dominio con la versione 2.13 o successiva, le autorizzazioni sono già disponibili. Se abiliti il framework di flusso su un dominio di OpenSearch servizio preesistente con la versione 2.11 o precedente e poi esegui l'aggiornamento alla versione 2.13 o successiva, devi definire il ruolo. `flow_framework_manager` Gli utenti senza privilegi di amministratore devono essere mappati a questo ruolo in modo da gestire gli indici a caldo sui domini che utilizzano il controllo granulare degli accessi. Per creare manualmente il ruolo `flow_framework_manager`, procedere nel seguente modo:
1. **In OpenSearch Dashboards, vai su **Sicurezza** e scegli Autorizzazioni.**
1. Scegliere **Crea gruppo di operazioni** e configurare i seguenti gruppi:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/flow-framework-permissions.html)
1. Scegliere **Ruoli**, quindi selezionare **Crea ruolo**.
1. **Assegna un nome al ruolo flow\$1framework\$1manager.**
1. Per **Autorizzazioni cluster**, selezionare `flow_framework_full_access` e `flow_framework_read_access`.
1. Per **Indice**, digitare `*`.
1. Per **Autorizzazioni indice**, selezionare `indices:admin/aliases/get`, `indices:admin/mappings/get` e `indices_monitor`.
1. Scegli **Create** (Crea).
1. Dopo aver creato il ruolo, [associalo](fgac.md#fgac-mapping) a qualsiasi ruolo utente o di backend che gestirà gli indici del framework di flusso.