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à.

Documentazione ambientale

La documentazione ambientale acquisisce le conversazioni tra paziente e medico in tempo reale e genera documentazione clinica strutturata per la revisione da parte del fornitore. Il servizio combina il riconoscimento vocale con l'intelligenza artificiale generativa per produrre note cliniche, estrarre terminologia medica, identificare i ruoli dei relatori e classificare i segmenti di dialogo.

La documentazione ambientale di Amazon Connect Health è disponibile nelle regioni Stati Uniti orientali (Virginia settentrionale) (us-east-1) e Stati Uniti occidentali (Oregon) (us-west-2).

Come funziona la documentazione ambientale

La documentazione ambientale utilizza lo streaming audio in tempo reale su HTTP/2 o. WebSocket Il flusso di lavoro include:

Requisiti tecnici

Specialità mediche supportate

La documentazione ambientale attualmente supporta le seguenti specialità:

Consenso e notifica al paziente

La documentazione ambientale di Amazon Connect Health utilizza l'intelligenza artificiale per acquisire e trascrivere conversazioni cliniche in tempo reale. Poiché questa funzionalità registra le comunicazioni vocali che possono contenere informazioni sanitarie protette (PHI), i clienti e i relativi integratori a valle sono responsabili del rispetto di tutte le leggi applicabili in materia di consenso, registrazione e privacy. Ciò include l'ottenimento di tutti i consensi richiesti dalla legge prima di abilitare la documentazione ambientale per qualsiasi incontro con il paziente. AWS non raccoglie il consenso dei pazienti per tuo conto.

È necessario ottenere il consenso appropriato da ogni paziente e da chiunque sia presente nella stanza quando viene utilizzata la documentazione ambientale. Oltre all'ottenimento del consenso, i pazienti devono essere informati che la visita verrà registrata e utilizzata da un fornitore di servizi di intelligenza artificiale per creare note cliniche, che le loro informazioni potrebbero essere condivise con i fornitori di servizi e che potranno rifiutare la visita senza alcun impatto sull'assistenza. I clienti e gli integratori devono conservare i registri del consenso dei pazienti, in conformità con la legge statale applicabile e le politiche interne di conservazione. I clienti devono assicurarsi che il consenso sia ottenuto in conformità con le pratiche sulla privacy della propria organizzazione.

Lingua di esempio:

«Prima di iniziare, voglio farvi sapere che la visita di oggi verrà registrata e monitorata da un fornitore di servizi di intelligenza artificiale per aiutarvi con la documentazione. Acconsenti a procedere?»

Gestione delle sottoscrizioni

Creazione di una sottoscrizione

Per creare un abbonamento, chiama l'operazione CreateSubscription API. Questo genera un codice univoco subscriptionId da utilizzare per autorizzare l'utente e avviare sessioni di streaming. Le sottoscrizioni vengono create automaticamente in modalità attivata.

Disattiva un abbonamento

Per impedire temporaneamente a un abbonamento di accettare nuove sessioni di streaming, chiama l'operatore dell'DeactivateSubscriptionAPI. Un abbonamento disattivato mantiene la sua configurazione e può essere riattivato in un secondo momento. In-progress gli stream vengono completati normalmente.

Riattiva un abbonamento

Gli abbonamenti disattivati possono essere riattivati chiamando l'operatore dell'ActivateSubscriptionAPI con. subscriptionId La misurazione a pagamento inizia immediatamente dopo la riattivazione.

Audio in streaming

La documentazione ambientale elabora l'audio in tempo reale tramite una connessione di streaming. L'applicazione apre una connessione, invia blocchi audio come messaggi codificati in base agli eventi e riceve i risultati della trascrizione man mano che la conversazione procede. La documentazione Ambient supporta due trasporti di streaming: e (). HTTP/2 WebSocket wss:// Entrambi i trasporti offrono le stesse funzionalità, con gli stessi requisiti di autenticazione e autorizzazione, quote e limitazione. Il comportamento della sessione (creazione, streaming e terminazione) è identico in entrambi i trasporti.

Se l'audio ha due canali, puoi utilizzare l'identificazione dei canali per trascrivere il discorso da ciascun canale separatamente. La documentazione ambientale attualmente supporta l'audio con un massimo di due canali. Nella trascrizione, ai canali vengono assegnate le etichette ch_0 e ch_1.

Oltre alle sezioni di trascrizione standard (trascrizioni ed elementi), le richieste con identificazione del canale abilitata includono una sezione channel_labels. Questa sezione contiene ogni enunciato o segno di punteggiatura, raggruppato per canale e per etichetta del canale associata, i timestamp e il punteggio di affidabilità associati. Tieni presente che se una persona su un canale parla contemporaneamente a una persona su un canale separato, i timestamp di ogni canale si sovrapporranno mentre le persone parlano l'una sull'altra.

Streaming tramite HTTP/2

HTTP/2 è il trasporto di streaming utilizzato dagli SDK AWS ed è adatto per applicazioni lato server e native. L'applicazione stabilisce una HTTP/2 connessione, invia blocchi audio e controlla gli eventi come messaggi di flusso di eventi e riceve gli eventi di trascrizione in tempo reale sulla stessa connessione. Quando utilizzi un SDK AWS, l'SDK gestisce automaticamente la configurazione della connessione, la firma delle richieste e la codifica del flusso di eventi.

Per la configurazione dettagliata HTTP/2 dello streaming e la codifica del flusso di eventi, consulta l'Amazon Connect Health API Reference.

Utilizzo degli SDK AWS

Il seguente esempio di codice mostra come configurare una sessione di streaming della documentazione ambientale di Amazon Connect Health utilizzando l'SDK AWS per Java 2.x.

package com.example.connecthealth;

import io.reactivex.rxjava3.core.BackpressureStrategy;
import io.reactivex.rxjava3.core.Flowable;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscriber;
import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.connecthealth.ConnectHealthAsyncClient;
import software.amazon.awssdk.services.connecthealth.model.*;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.TargetDataLine;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UncheckedIOException;
import java.util.Arrays;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;

public class MedicalScribeStreamingApp {
    private static final int CHUNK_SIZE_IN_BYTES = 6400;
    private static final int SAMPLE_RATE = 16000;
    private static final Region REGION = Region.US_WEST_2;
    private static final String SESSION_ID = UUID.randomUUID().toString();
    private static final String DOMAIN_ID = "your-domain-id";
    private static final String SUBSCRIPTION_ID = "your-subscription-id";
    private static final String OUTPUT_S3_URI = "s3://your-bucket/output/";
    private static ConnectHealthAsyncClient client;

    public static void main(String[] args) {
        client = ConnectHealthAsyncClient.builder()
                .credentialsProvider(getCredentials())
                .httpClientBuilder(NettyNioAsyncHttpClient.builder())
                .region(REGION)
                .build();
        try {
            StartMedicalScribeListeningSessionRequest request =
                    StartMedicalScribeListeningSessionRequest.builder()
                            .sessionId(SESSION_ID)
                            .domainId(DOMAIN_ID)
                            .subscriptionId(SUBSCRIPTION_ID)
                            .languageCode(MedicalScribeLanguageCode.EN_US)
                            .mediaSampleRateHertz(SAMPLE_RATE)
                            .mediaEncoding(MedicalScribeMediaEncoding.PCM)
                            .build();

            MedicalScribeInputStream endSessionEvent =
                    MedicalScribeInputStream.sessionControlEventBuilder()
                            .type(MedicalScribeSessionControlEventType.END_OF_SESSION)
                            .build();

            CompletableFuture<Void> result = client.startMedicalScribeListeningSession(
                    request,
                    new AudioStreamPublisher(
                            getStreamFromMic(),
                            getConfigurationEvent(),
                            endSessionEvent
                    ),
                    getResponseHandler()
            );
            result.get();
            client.close();
        } catch (Exception e) {
            System.err.println("Error occurred: " + e.getMessage());
            e.printStackTrace();
        }
    }

    private static AudioInputStream getStreamFromMic() throws LineUnavailableException {
        AudioFormat format = new AudioFormat(SAMPLE_RATE, 16, 1, true, false);
        DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
        if (!AudioSystem.isLineSupported(info)) {
            throw new LineUnavailableException("Microphone line not supported");
        }
        TargetDataLine line = (TargetDataLine) AudioSystem.getLine(info);
        line.open(format);
        line.start();
        System.out.println("Recording... Press Enter to stop");
        Thread monitorThread = new Thread(() -> {
            try {
                System.in.read();
                line.stop();
                line.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
        monitorThread.setDaemon(true);
        monitorThread.start();
        return new AudioInputStream(
                new BufferedInputStream(new AudioInputStream(line)),
                format,
                AudioSystem.NOT_SPECIFIED
        );
    }

    private static AwsCredentialsProvider getCredentials() {
        return DefaultCredentialsProvider.create();
    }

    private static StartMedicalScribeListeningSessionResponseHandler getResponseHandler() {
        return StartMedicalScribeListeningSessionResponseHandler.builder()
                .onResponse(r -> {
                    System.out.println("Session started: " + r.sessionId());
                    System.out.println("Domain ID: " + r.domainId());
                    System.out.println("Subscription ID: " + r.subscriptionId());
                    System.out.println("Request ID: " + r.requestId());
                })
                .onError(e -> {
                    System.err.println("Stream error: " + e.getMessage());
                    e.printStackTrace();
                })
                .onComplete(() -> {
                    System.out.println("=== Stream completed successfully ===");
                })
                .subscriber(event -> {
                    if (event instanceof MedicalScribeTranscriptEvent) {
                        MedicalScribeTranscriptSegment segment =
                                ((MedicalScribeTranscriptEvent) event).transcriptSegment();
                        if (segment != null && segment.content() != null) {
                            System.out.printf("[%s][Channel %s] %s%n",
                                    segment.isPartial() ? "PARTIAL" : "FINAL",
                                    segment.channelId(),
                                    segment.content()
                            );
                        }
                    }
                })
                .build();
    }

    private static MedicalScribeConfigurationEvent getConfigurationEvent() {
        return MedicalScribeConfigurationEvent.builder()
                .postStreamActionSettings(
                        MedicalScribePostStreamActionSettings.builder()
                                .outputS3Uri(OUTPUT_S3_URI)
                                .clinicalNoteGenerationSettings(
                                        ClinicalNoteGenerationSettings.builder()
                                                .noteTemplateSettings(
                                                        NoteTemplateSettings.fromManagedTemplate(
                                                                ManagedTemplate.builder()
                                                                        .templateType(ManagedNoteTemplate.SOAP)
                                                                        .build()
                                                        )
                                                )
                                                .build()
                                )
                                .build()
                )
                .channelDefinitions(Arrays.asList(
                        MedicalScribeChannelDefinition.builder()
                                .channelId(0)
                                .participantRole(MedicalScribeParticipantRole.CLINICIAN)
                                .build(),
                        MedicalScribeChannelDefinition.builder()
                                .channelId(1)
                                .participantRole(MedicalScribeParticipantRole.PATIENT)
                                .build()
                ))
                .build();
    }

    private static class AudioStreamPublisher implements Publisher<MedicalScribeInputStream> {
        private final InputStream audioInputStream;
        private final MedicalScribeConfigurationEvent configEvent;
        private final MedicalScribeInputStream endSessionEvent;

        private AudioStreamPublisher(
                AudioInputStream audioInputStream,
                MedicalScribeConfigurationEvent configEvent,
                MedicalScribeInputStream endSessionEvent) {
            this.audioInputStream = audioInputStream;
            this.configEvent = configEvent;
            this.endSessionEvent = endSessionEvent;
        }

        @Override
        public void subscribe(Subscriber<? super MedicalScribeInputStream> subscriber) {
            createAudioFlowable()
                    .doOnComplete(() -> {
                        try {
                            audioInputStream.close();
                        } catch (IOException e) {
                            throw new UncheckedIOException(e);
                        }
                    })
                    .subscribe(subscriber);
        }

        private Flowable<MedicalScribeInputStream> createAudioFlowable() {
            Flowable<MedicalScribeInputStream> configFlow = Flowable.just(
                    MedicalScribeInputStream.fromConfigurationEvent(configEvent)
            );
            Flowable<MedicalScribeInputStream> audioFlow = Flowable.create(emitter -> {
                byte[] buffer = new byte[CHUNK_SIZE_IN_BYTES];
                int bytesRead;
                try {
                    while (!emitter.isCancelled() && (bytesRead = audioInputStream.read(buffer)) > 0) {
                        byte[] audioData = bytesRead < buffer.length
                                ? Arrays.copyOfRange(buffer, 0, bytesRead)
                                : buffer;
                        MedicalScribeInputStream audioEvent =
                                MedicalScribeInputStream.fromAudioEvent(
                                        MedicalScribeAudioEvent.builder()
                                                .audioChunk(SdkBytes.fromByteArray(audioData))
                                                .build()
                                );
                        emitter.onNext(audioEvent);
                    }
                    emitter.onComplete();
                } catch (IOException e) {
                    emitter.onError(e);
                }
            }, BackpressureStrategy.BUFFER);
            Flowable<MedicalScribeInputStream> endFlow = Flowable.just(endSessionEvent);
            return Flowable.concat(configFlow, audioFlow, endFlow);
        }
    }
}

Streaming su WebSocket

WebSocket il supporto consente di trasmettere l'audio per la documentazione ambientale da un browser Web o da un altro WebSocket client. Tutte le WebSocket connessioni utilizzano TLS ()wss://.

WebSocket endpoint

Connect all' WebSocket endpoint per la regione in cui si utilizza la documentazione ambientale:

Autenticazione di una connessione WebSocket

Autentichi una WebSocket connessione con un URL predefinito. Per creare l'URL predefinito, firma una GET richiesta all' WebSocket endpoint con AWS Signature versione 4 (SigV4) e incorpora i parametri di firma (X-Amz-Algorithm,,, X-Amz-Credential X-Amz-Date X-Amz-ExpiresX-Amz-Signature, eX-Amz-SignedHeaders) e i parametri di sessione come parametri della stringa di query. Il servizio convalida l'URL predefinito quando viene stabilita la connessione. Se l'URL predefinito non è valido, è scaduto o non è autorizzato, il servizio rifiuta la sessione restituendo un errore e chiudendo la connessione.

Il valore massimo per X-Amz-Expires è 60 secondi (1 minuto). Una volta stabilita la connessione, la firma dell'URL predefinito diventa la firma iniziale utilizzata per firmare ogni frame di event-stream successivo, fornendo un'autorizzazione continua per tutta la durata della connessione.

Non è richiesta alcuna nuova azione IAM per. WebSocket Il servizio autorizza le WebSocket connessioni con la stessa health-agent:StartMedicalScribeListeningSession autorizzazione utilizzata per lo HTTP/2 streaming.

L'esempio seguente mostra il formato di un URL predefinito. WebSocket Le interruzioni di riga vengono aggiunte per motivi di leggibilità.

wss://streaming.health-agent.us-west-2.api.aws/medical-scribe-stream-websocket
    ?X-Amz-Algorithm=AWS4-HMAC-SHA256
    &X-Amz-Credential=<access-key>/<date>/<region>/health-agent/aws4_request
    &X-Amz-Date=<ISO8601-datetime>
    &X-Amz-Expires=60
    &X-Amz-Security-Token=<session-token>
    &X-Amz-SignedHeaders=host
    &X-Amz-Signature=<signature>

Firma dei frame event-stream

Ogni frame di eventi inviato dopo l'aggiornamento (configurazione, audio e controllo della sessione) deve essere firmato individualmente. Ogni frame contiene due intestazioni del flusso di eventi: :date (il timestamp della firma) e (la firma del frame). :chunk-signature Le firme dei frame formano una catena: ogni firma viene calcolata a partire dalla firma del frame precedente e le prime catene di frame dal valore dell'URL predefinito. X-Amz-Signature

Per firmare un frame, crea una stringa da firmare utilizzando l'AWS4-HMAC-SHA256-PAYLOADalgoritmo, quindi calcolane una HMAC-SHA256 sovrapposizione con una chiave di firma SigV4 derivata dalla data, dalla regione e dal servizio della richiesta. health-agent La stringa da firmare ha il seguente formato:

AWS4-HMAC-SHA256-PAYLOAD
<date>                       # signing time, ISO 8601 basic format (YYYYMMDDTHHMMSSZ)
<date-stamp>/<region>/health-agent/aws4_request
<prior-signature>            # hex; for the first frame, the X-Amz-Signature from the presigned URL
<hashed-headers>             # SHA-256 hex digest of the encoded :date header
<hashed-payload>             # SHA-256 hex digest of the frame payload

Calcola la firma e allegala alla cornice:

La chiave di firma viene derivata allo stesso modo di qualsiasi richiesta SigV4: HMAC-SHA256 concatenate il timbro della data, la regione, il nome del servizio (health-agent) eaws4_request, a partire dalla chiave di accesso segreta con il prefisso. AWS4

Invio dell'audio tramite WebSocket

Una volta stabilita la connessione, inviate la configurazione della sessione, quindi trasmettete l'audio come eventi audio binari. Ciascuno binaryAudioEvent contiene una parte di byte PCM o FLAC non elaborati. Il servizio restituisce gli eventi di trascrizione sulla stessa connessione in tempo reale. Per terminare la sessione, invia un evento di controllo END_OF_SESSION della sessione.

WebSocket consigli per i clienti

Il servizio segnala la fine di una sessione inviando un frame WebSocket chiuso. Progetta il tuo client in modo che gestisca la chiusura della connessione con garbo:

Gli SDK AWS non supportano WebSocket lo streaming. Per eseguire lo streaming WebSocket, connettiti direttamente all'endpoint come descritto in questa sezione. L'Amazon Connect Health API Reference documenta le operazioni dell'API e i relativi parametri di richiesta e risposta, che si applicano a entrambi i trasporti.

Archiviazione

Una posizione di archiviazione S3 deve essere specificata all'inizio di una sessione. Gli artefatti di output vengono archiviati nella seguente posizione di base:

s3://{customer-provided-uri}/health-agent-listening-session/{domainId}/{subscriptionId}/{sessionId}/post-stream-action/

Le note cliniche vengono archiviate in una clinical-notes cartella in questa posizione di base.

Contesto del paziente

Il contesto del paziente fornisce all'operatore l'anamnesi clinica prima della conversazione tramite il parametro encounterContext API. L'encounterContextoggetto contiene il campounstructuredContext, che accetta fino a 10 KB di dati di testo per ogni sessione. Quando si include il contesto del paziente, l'agente lo utilizza per arricchire la documentazione generata con informazioni di base che non sono state discusse esplicitamente durante la visita.

Il contesto del paziente può includere:

Il contesto viene utilizzato in tutta la nota generata per migliorare la specificità e l'accuratezza quando le informazioni necessarie non sono presenti solo nella trascrizione, con una mappatura delle evidenze ai materiali di partenza per la revisione da parte del medico.

Esempio di contesto del paziente

## Patient Information
Name: Patricia Underwood
Age: 28 years
Sex: female
Pronouns: she/her
MEDICATIONS:
Ondansetron 4mg PO PRN - Nausea/vomiting
Dicyclomine 20mg PO BID PRN - Abdominal cramping
Sertraline 50mg PO daily - Depression
Ferrous sulfate 325mg PO TID - Iron deficiency anemia
ALLERGIES: NKDA (No Known Drug Allergies)
PAST MEDICAL HISTORY:
Brainstem pilocytic astrocytoma diagnosed 04/2010
Posterior fossa craniotomy with gross total resection 05/12/2010
Hyperprolactinemia diagnosed 08/2013
Autoimmune hemolytic anemia diagnosed 12/2012
Splenomegaly secondary to autoimmune hemolytic anemia 01/2013
Major depressive disorder diagnosed 08/2012
Substance use disorder (heroin) in sustained remission since 04/2011
Tobacco use disorder, quit 09/15/2013 (10 pack-year history)
Iron deficiency anemia diagnosed 01/2013
Gastroesophageal reflux disease diagnosed 05/2013
Appendectomy 07/23/2009 (uncomplicated laparoscopic)
Wisdom teeth extraction 11/08/2008
FAMILY HISTORY:
Maternal grandmother: Cervical cancer, ovarian cancer, dementia/Alzheimer's
Maternal aunt: Cervical cancer
Paternal grandfather: Type 2 diabetes, hypertension, kidney transplant
Maternal great-grandfather: Colon cancer
Multiple maternal great-uncles: Colon cancer
No family history of breast, uterine, or cardiac disease
SOCIAL HISTORY:
Tobacco: Former smoker, quit 09/15/2013 (10 pack-year history)
Alcohol: Not documented
Illicit drugs: History of IV heroin use, abstinent since 04/2011, occasional marijuana use
Sexual history: Single, sexually active, monogamous relationship since 05/2012
Previous relationship with military personnel ended 03/2012
Employment: Lives independently, employed
Contraception: Not currently using
Former plasma donor, discontinued 10/2013 due to positive syphilis screening
PROBLEM LIST:
History of brainstem pilocytic astrocytoma (C71.7) - Diagnosed 04/2010 with posterior fossa craniotomy and gross total resection 05/12/2010. Annual MRI surveillance shows post-surgical changes, no residual tumor. Most recent MRI 10/18/2013 normal. Followed by neurology with annual visits.
Hyperprolactinemia (E22.1) - Diagnosed 08/2013 with prolactin 45.2 ng/mL (normal <25). Referred to neurology for pituitary evaluation. Recent MRI 10/18/2013 shows normal pituitary gland. Not currently on treatment. Neurology follow-up scheduled.
Autoimmune hemolytic anemia with splenomegaly (D59.1) - Diagnosed 12/2012-01/2013. Positive direct Coombs test, elevated LDH 420 U/L, low haptoglobin <10 mg/dL, reticulocyte count 8.2%. Associated splenomegaly. Managed by primary care physician. On iron supplementation for concurrent iron deficiency.
Major depressive disorder, mild (F32.0) - Diagnosed 08/2012. Started sertraline 50mg daily 09/08/2012 with good response. Stable mood, no current suicidal ideation. Continues on current regimen.
Substance use disorder (heroin), in sustained remission (F11.21) - History of IV drug use, abstinent since 04/2011. Not currently in formal treatment program. Maintains abstinence, occasional marijuana use.
Iron deficiency anemia (D50.9) - Diagnosed 01/2013 concurrent with autoimmune hemolytic anemia. Started ferrous sulfate 325mg TID 01/14/2013. Recent Hgb 9.8 g/dL, Hct 29%, MCV 102 fL.
Gastroesophageal reflux disease (K21.9) - Diagnosed 05/2013. Managed with lifestyle modifications. Symptoms of nausea and vomiting, taking ondansetron and dicyclomine PRN.
RECENT LABS (Various dates 2013):
Prolactin: 45.2 ng/mL (08/22/2013, elevated)
CBC: Hgb 9.8, Hct 29%, MCV 102 fL (10/28/2013)
Direct Coombs: Positive (01/14/2013)
LDH: 420 U/L, Haptoglobin <10 mg/dL (01/14/2013)
MRI brain with contrast: Normal pituitary, post-surgical changes only (10/18/2013)
Pap smear: Normal cytology, HPV negative (11/15/2012)
Mammogram: BI-RADS 1, normal (02/28/2013)

Modelli di note cliniche

I modelli definiscono la struttura, le sezioni e le regole di formattazione seguite dall'agente durante la generazione della documentazione clinica. È necessario specificare un formato di output passando un oggetto di configurazione al parametro noteTemplateSettings API ad ogni sessione. La documentazione Ambient supporta due metodi per specificare il formato di output: modelli gestiti o modelli personalizzati.

Modelli gestiti

La documentazione ambientale fornisce sette modelli di note predefiniti. L'oggetto di configurazione per i modelli gestiti specifica managedTemplate il modello tramite il parametro. templateType Il modello predefinito è HISTORY_AND_PHYSICAL.

Sezioni HISTORY_AND_PHYSICAL

sezioni PHYSICAL_SOAP e BEHAVIORAL_SOAP

Sezioni GIRPP

sezioni BIRP

Sezioni SIRP

sezioni DAP

modelli personalizzati

La documentazione ambientale utilizza un modello di personalizzazione a due livelli: Base e Output Specification. Questi due livelli sono gestiti in un oggetto di configurazione,. customTemplate L'oggetto customTemplate di configurazione contiene due parametri: templateType imposta il modello Base e templateInstructions contiene la specifica di output.

Base (templateType) imposta la struttura organizzativa dei fatti clinici rilevati durante la conversazione. Sono supportati i seguenti modelli di base:

L'oggetto Output Specification (templateInstructions) è organizzato come una matrice di istruzioni, con una sectionHeader che definisce il nome della sezione e sectionInstructions che combina istruzioni e un modello per quella sezione.

Le istruzioni di personalizzazione possono includere tre tipi di direttive:

I modelli possono essere forniti come testo con segnaposti, schemi JSON strutturati o note precedenti di esempio.

Esempio di istruzione di personalizzazione

L'esempio seguente mostra un'istruzione di personalizzazione per una nota SOAP utilizzando l'oggetto di customTemplate configurazione.

{
  "clinicalNoteGenerationSettings": {
    "noteTemplateSettings": {
      "customTemplate": {
        "templateType": "HISTORY_AND_PHYSICAL",
        "templateInstructions": [
          {
            "sectionHeader": "Subjective",
            "sectionInstruction": "You will be generating a SOAP note one section at a time, starting with the `S` section. Please use this template when generating the `S` section:\n<template>\nSUBJECTIVE:\nChief Complaint: <Brief statement, in patient's own words, if available>\nHistory of Present Illness: <Narrative description of current symptoms, onset, duration, quality, severity, timing, context, modifying factors, associated symptoms.>\nReview of Systems:\n• Constitutional: <fever, chills, weight changes, fatigue>\n• Cardiovascular: <chest pain, palpitations, shortness of breath>\n• Respiratory: <cough, dyspnea, wheezing>\n• GI: <nausea, vomiting, diarrhea, constipation, abdominal pain>\n• GU: <dysuria, frequency, urgency, hematuria>\n• Musculoskeletal: <joint pain, muscle weakness, back pain>\n• Neurological: <headache, dizziness, numbness, weakness>\n• Psychiatric: <mood changes, anxiety, sleep disturbances>\n• All other systems negative unless noted above Past Medical History: <List chronic conditions>\nPast Surgical History: <List previous surgeries with dates>\nMedications: <Current medications with doses>\nAllergies: <Drug allergies and reactions, or NKDA>\nSocial History: <Tobacco, alcohol, drugs, occupation, living situation>\nFamily History: <Relevant family medical history>\n</template>"
          }
        ]
      }
    }
  }
}

Le migliori pratiche relative ai modelli

L'agente raggiunge un'aderenza media del layout del 97,7% con modelli ben progettati.

Output

La documentazione ambientale genera tre file di output:

File di trascrizione

Il file di trascrizione contiene una trascrizione dettagliata con timestamp a livello di parola. Amazon Connect Health aggiunge il rilevamento del ruolo dei partecipanti, etichettando ogni oratore come MEDICO o PAZIENTE. Se una conversazione ha più di un partecipante in ogni categoria, a ciascun partecipante viene assegnato un numero (ad esempio,). CLINICIAN_0 CLINICIAN_1

Documentazione clinica e file di mappatura delle evidenze

Il file di documentazione clinica contiene la nota clinica strutturata generata dalla conversazione paziente-medico e una sezione che collega ogni affermazione generata alla fonte contenuta nella trascrizione della conversazione o nell'immissione del contesto del paziente.

Il file segue il modello gestito o le istruzioni di personalizzazione fornite all'inizio della sessione. Ogni sezione può contenere contenuti derivati dalla visita (dalla conversazione) e contenuti derivati dal contesto (dall'input del contesto del paziente). Sono supportati diversi formati di output: prose/free -text e JSON strutturato a seconda della configurazione del modello. La sezione dedicata alla mappatura delle evidenze consente ai medici di verificare l'origine di qualsiasi contenuto. AI-generated Ogni voce della mappatura contiene la frase generata e il riferimento alla fonte. transcript/context

After-visit file di riepilogo

Il file di riepilogo dopo la visita contiene un riepilogo rivolto al paziente scritto in un linguaggio accessibile per la revisione e la finalizzazione da parte del medico. Include una descrizione in linguaggio semplice della visita, i farmaci in uso con dosaggio e frequenza, le istruzioni di follow-up fornite dal medico e le azioni da intraprendere per il paziente.

Il riepilogo viene generato dal file di documentazione clinica, non direttamente dalla trascrizione, garantendo la coerenza tra la nota clinica e il riepilogo rivolto al paziente.

Per informazioni complete sui parametri dell'API, sugli request/response schemi e sulle istruzioni di configurazione dello streaming, consulta l'Amazon Connect Health API Reference.