Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Documentation sur l'environnement

La documentation ambiante capture les conversations entre le patient et le clinicien en temps réel et génère une documentation clinique structurée pour examen par le professionnel de la santé. Le service associe la reconnaissance vocale à l'IA générative pour produire des notes cliniques, extraire de la terminologie médicale, identifier les rôles des orateurs et classer les segments de dialogue.

La documentation relative à la température ambiante d'Amazon Connect Health est disponible dans les régions USA Est (Virginie du Nordus-east-1) () et USA Ouest (Oregonus-west-2) ().

Comment fonctionne la documentation sur l'environnement

La documentation ambiante utilise le streaming audio en temps réel HTTP/2 via ou WebSocket. Le flux de travail inclut :

Exigences techniques

Spécialités médicales prises en charge

La documentation sur Ambient prend actuellement en charge les spécialités suivantes :

Consentement et notification au patient

La documentation ambiante d'Amazon Connect Health utilise l'IA pour capturer et transcrire les conversations cliniques en temps réel. Étant donné que cette fonctionnalité enregistre les communications vocales susceptibles de contenir des informations de santé protégées (PHI), les clients et leurs intégrateurs en aval sont tenus de respecter toutes les lois applicables en matière de consentement, d'enregistrement et de confidentialité. Cela inclut l'obtention de tous les consentements légalement requis avant d'autoriser la documentation sur le milieu ambiant pour toute consultation avec un patient. AWS ne recueille pas le consentement des patients en votre nom.

Le consentement approprié doit être obtenu de chaque patient et de toute personne présente dans la pièce lorsque la documentation sur le milieu ambiant est utilisée. Dans le cadre de l'obtention du consentement, les patients doivent être informés que la visite sera enregistrée et utilisée par un fournisseur de services d'IA pour créer des notes cliniques, que leurs informations peuvent être partagées avec les prestataires de services et qu'ils peuvent refuser sans aucune incidence sur leurs soins. Les clients et les intégrateurs doivent conserver les dossiers de consentement des patients, conformément à la législation applicable de l'État et aux politiques de conservation internes. Les clients doivent s'assurer que le consentement est obtenu conformément aux pratiques de confidentialité de leur organisation.

Langue d'exemple :

« Avant de commencer, je tiens à vous informer que la visite d'aujourd'hui sera enregistrée et surveillée par un fournisseur de services d'intelligence artificielle pour faciliter la documentation. Acceptez-vous de continuer ? »

Gestion des abonnements

Créer un abonnement

Pour créer un abonnement, appelez l'opération CreateSubscription API. Cela génère un code unique subscriptionId que vous utilisez pour autoriser l'utilisateur et démarrer des sessions de streaming. Les abonnements sont automatiquement créés en mode activé.

Désactiver un abonnement

Pour empêcher temporairement un abonnement d'accepter de nouvelles sessions de streaming, appelez l'opération DeactivateSubscription API. Un abonnement désactivé conserve sa configuration et peut être réactivé ultérieurement. In-progress les flux se terminent normalement.

Réactiver un abonnement

Les abonnements désactivés peuvent être réactivés en appelant l'opération ActivateSubscription API avec le. subscriptionId Le comptage payant commence immédiatement après la réactivation.

Diffusion audio

La documentation ambiante traite le son en temps réel via une connexion de streaming. Votre application ouvre une connexion, envoie des fragments audio sous forme de messages codés par événement et reçoit les résultats de la transcription au fur et à mesure que la conversation progresse. La documentation Ambient prend en charge deux modes de transport en continu : HTTP/2 et WebSocket (wss://). Les deux transports offrent les mêmes fonctionnalités, avec les mêmes exigences d'authentification et d'autorisation, les mêmes quotas et la même régulation. Le comportement des sessions (création, diffusion et terminaison) est identique dans les deux transports.

Si votre audio comporte deux canaux, vous pouvez utiliser l'identification des canaux pour transcrire le discours de chaque canal séparément. La documentation relative à l'environnement prend actuellement en charge le son sur deux canaux au maximum. Dans votre transcription, les canaux se voient attribuer les étiquettes ch_0 et ch_1.

Outre les sections de transcription standard (transcriptions et éléments), les demandes pour lesquelles l'identification du canal est activée incluent une section channel_labels. Cette section contient chaque énoncé ou signe de ponctuation, groupé par canal, ainsi que l’étiquette de canal, les horodatages et le score de confiance associés. Notez que si une personne parle sur un canal en même temps qu’une autre personne sur un autre canal, les horodatages de chaque canal se chevauchent pendant que les personnes parlent l’une sur l’autre.

Diffusion en continu HTTP/2

HTTP/2 est le transport de streaming utilisé par les kits SDK AWS et convient aux applications natives et côté serveur. Votre application établit une HTTP/2 connexion, envoie des fragments audio et des événements de contrôle sous forme de messages de flux d'événements, et reçoit les événements de transcription en temps réel via la même connexion. Lorsque vous utilisez un SDK AWS, celui-ci gère pour vous la configuration de la connexion, la signature des demandes et le codage des flux d'événements.

Pour une configuration détaillée du HTTP/2 streaming et le codage des flux d'événements, consultez le manuel Amazon Connect Health API Reference.

Utilisation des kits SDK AWS

L'exemple de code suivant montre comment configurer une session de streaming de documentation Amazon Connect Health ambient à l'aide du SDK AWS pour 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);
        }
    }
}

Diffusion en continu WebSocket

WebSocket le support vous permet de diffuser du son pour la documentation ambiante à partir d'un navigateur Web ou d'un autre WebSocket client. Toutes les WebSocket connexions utilisent TLS (wss://).

WebSocket point de terminaison

Connectez-vous au WebSocket point de terminaison de la région dans laquelle vous utilisez la documentation sur l'environnement :

Authentification d'une connexion WebSocket

Vous authentifiez une WebSocket connexion à l'aide d'une URL présignée. Pour créer l'URL présignée, signez une GET demande au WebSocket point de terminaison avec AWS Signature Version 4 (Sigv4) et intégrez les paramètres de signature (X-Amz-Algorithm,,, X-Amz-Credential X-Amz-Date X-Amz-ExpiresX-Amz-Signature, etX-Amz-SignedHeaders) ainsi que les paramètres de session sous forme de paramètres de chaîne de requête. Le service valide l'URL présignée lorsque la connexion est établie. Si l'URL présignée n'est pas valide, a expiré ou n'est pas autorisée, le service rejette la session en renvoyant un message d'erreur et en fermant la connexion.

La valeur maximale pour X-Amz-Expires est de 60 secondes (1 minute). Une fois la connexion établie, la signature provenant de l'URL présignée devient la signature initiale utilisée pour signer chaque trame de flux d'événements suivante, fournissant ainsi une autorisation continue pendant toute la durée de vie de la connexion.

Aucune nouvelle action IAM n'est requise pour WebSocket. Le service autorise les WebSocket connexions avec la même health-agent:StartMedicalScribeListeningSession autorisation que celle utilisée pour le HTTP/2 streaming.

L'exemple suivant montre le format d'une WebSocket URL présignée. Des sauts de ligne sont ajoutés pour plus de lisibilité.

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>

Signature de cadres de flux d'événements

Chaque trame de flux d'événements que vous envoyez après la mise à niveau (configuration, audio et contrôle de session) doit être signée individuellement. Chaque image contient deux en-têtes de flux d'événements : :date (l'horodatage de signature) et :chunk-signature (la signature du cadre). Les signatures de trame forment une chaîne : chaque signature est calculée à partir de la signature de la trame précédente, et la première chaîne de trames à partir de la X-Amz-Signature valeur de l'URL présignée.

Pour signer un cadre, créez une chaîne à signer à l'aide de l'AWS4-HMAC-SHA256-PAYLOADalgorithme, puis calculez le HMAC-SHA256 dessus avec une clé de signature SigV4 dérivée de la date, de la région et du health-agent service de la demande. La chaîne à signer est au format suivant :

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

Calculez la signature et attachez-la au cadre :

La clé de signature est dérivée de la même manière que pour toute demande SigV4 : chaîne HMAC-SHA256 sur l'horodatage, la région, le nom du service (health-agent) etaws4_request, en commençant par votre clé d'accès secrète préfixée par. AWS4

Envoi audio WebSocket

Une fois la connexion établie, envoyez la configuration de votre session, puis diffusez le son sous forme d'événements audio binaires. Chacun binaryAudioEvent contient un bloc d'octets PCM ou FLAC bruts. Le service renvoie les événements de transcription via la même connexion en temps réel. Pour terminer la session, envoyez un événement de contrôle de END_OF_SESSION session.

WebSocket recommandations des clients

Le service signale la fin d'une session en envoyant un cadre de WebSocket fermeture. Concevez votre client de manière à ce qu'il gère la fermeture de la connexion avec élégance :

Les kits SDK AWS ne prennent pas WebSocket en charge le streaming. Pour diffuser WebSocket, connectez-vous directement au point de terminaison comme décrit dans cette section. Le Amazon Connect Health API Reference documente les opérations d'API et leurs paramètres de demande et de réponse, qui s'appliquent aux deux transports.

Stockage

Un emplacement de stockage S3 doit être spécifié au début d'une session. Les artefacts de sortie sont stockés à l'emplacement de base suivant :

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

Les notes cliniques sont stockées dans un clinical-notes dossier à cet emplacement de base.

Contexte du patient

Le contexte du patient fournit à l'agent l'historique clinique avant la conversation via le paramètre encounterContext API. L'encounterContextobjet contient le champunstructuredContext, qui accepte jusqu'à 10 Ko de données texte pour chaque session. Lorsque vous incluez le contexte du patient, l'agent l'utilise pour enrichir la documentation générée avec des informations générales qui n'ont pas été abordées explicitement lors de la visite.

Le contexte du patient peut inclure :

Le contexte est utilisé tout au long de la note générée pour améliorer la spécificité et la précision lorsque les informations nécessaires ne sont pas présentes uniquement dans la transcription, avec une mise en correspondance des preuves avec les documents sources pour examen par le clinicien.

Exemple de contexte pour le patient

## 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)

Modèles de notes cliniques

Les modèles définissent la structure, les sections et les règles de mise en forme que l'agent suit lors de la génération de la documentation clinique. Vous devez spécifier un format de sortie en transmettant un objet de configuration au paramètre noteTemplateSettings API à chaque session. La documentation ambiante prend en charge deux méthodes pour spécifier le format de sortie : les modèles gérés ou les modèles personnalisés.

Modèles gérés

La documentation Ambient fournit sept modèles de notes prédéfinis. L'objet de configuration pour les modèles gérés spécifie le modèle par le biais du templateType paramètre. managedTemplate Le modèle par défaut est HISTORY_AND_PHYSICAL.

Sections HISTORY_ET_PHYSICAL

Sections PHYSICAL_SOAP et BEHAVIORAL_SOAP

Rubriques du GIRPP

Rubriques BIRP

Rubriques SIRP

Sections DAP

Modèles personnalisés

La documentation ambiante utilise un modèle de personnalisation à deux niveaux : spécification de base et spécification de sortie. Ces deux couches sont gérées dans un objet de configuration,customTemplate. L'objet customTemplate de configuration contient deux paramètres : templateType définit le modèle de base et templateInstructions contient la spécification de sortie.

La base (templateType) définit la structure organisationnelle des faits cliniques détectés au cours de la conversation. Les modèles de base suivants sont pris en charge :

L'objet de spécification de sortie (templateInstructions) est organisé sous la forme d'un tableau d'instructions, avec un sectionHeader qui définit le nom de la section et sectionInstructions qui combine des instructions et un modèle pour cette section.

Les instructions de personnalisation peuvent inclure trois types de directives :

Les modèles peuvent être fournis sous forme de texte avec des espaces réservés, des schémas JSON structurés ou des exemples de notes précédentes.

Exemple d'instruction de personnalisation

L'exemple suivant montre une instruction de personnalisation pour une note SOAP utilisant l'objet customTemplate de configuration.

{
  "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>"
          }
        ]
      }
    }
  }
}

Bonnes pratiques en matière de modèles

L'agent atteint 97,7 % de conformité moyenne à la mise en page grâce à des modèles bien conçus.

Sorties

La documentation ambiante génère trois fichiers de sortie :

Fichier de transcription

Le fichier de transcription contient une transcription détaillée avec des horodatages au niveau des mots. Amazon Connect Health ajoute la détection des rôles des participants, en étiquetant chaque intervenant comme CLINICIEN ou PATIENT. Si une conversation compte plusieurs participants dans chaque catégorie, un numéro est attribué à chaque participant (par exemple,CLINICIAN_0,CLINICIAN_1).

Documentation clinique et fichier de cartographie des preuves

Le fichier de documentation clinique contient la note clinique structurée générée à partir de la conversation patient-clinicien et une section reliant chaque déclaration générée à sa source dans la transcription de la conversation ou dans la saisie contextuelle du patient.

Le fichier suit le modèle géré ou les instructions de personnalisation fournies au début de la session. Chaque section peut contenir du contenu dérivé de la visite (issu de la conversation) et du contenu dérivé du contexte (issu de la saisie contextuelle du patient). Plusieurs formats de sortie sont pris en charge : prose/free -text et JSON structuré en fonction de la configuration du modèle. La section de cartographie des preuves permet aux cliniciens de vérifier l'origine de tout AI-generated contenu. Chaque entrée de mappage contient la phrase générée et la transcript/context référence source.

After-visit fichier récapitulatif

Le dossier récapitulatif après la visite contient un résumé destiné au patient rédigé dans un langage accessible pour examen et finalisation par un clinicien. Il comprend une description en langage clair de la visite, les médicaments actuels avec la posologie et la fréquence, les instructions de suivi du clinicien et les mesures à prendre pour le patient.

Le résumé est généré à partir du dossier de documentation clinique, et non directement à partir du relevé de notes, ce qui garantit la cohérence entre la note clinique et le résumé destiné au patient.

Pour obtenir des informations complètes sur les paramètres d'API, request/response les schémas et les instructions de configuration du streaming, consultez le manuel Amazon Connect Health API Reference.