Developer Learning Path

Step-by-step guided journey to integrate Suki Ambient Clinical Intelligence using the available workflows

Follow this structured path to successfully integrate Suki’s AI-powered healthcare capabilities. Each step builds on the previous one, ensuring you have a solid foundation before moving forward.

Estimated Total Time: 4-6 weeks from start to production deployment

Foundation setup

Step 1: Partner onboarding

Goal: Get registered with Suki and receive your Partner ID

What You'll Do

• Contact Suki partnership team.
• Provide business information and authentication method.
• Receive your unique partner_id.

Prerequisites: Business information, chosen authentication method.

Time: 3-5 business days.

Next Step: Once you have your partner_id, move to Step 2.

Step 2: Authentication setup

Goal: Configure secure authentication between your system and Suki

What You'll Do

• Choose authentication method (JWKS, Okta, JWT Assertion).
• Set up your identity provider integration.
• Test token generation and validation.

Prerequisites: Partner ID from Step 1, access to your identity provider.

Time: 2-3 days.

Next Step: With authentication working, choose your integration path.

---

Step 3: Choose your integration path

Depending on the workflow you choose, you will need to choose the best integration method for your application. Most partner products require a combination of SDKs and APIs. Decide how much UI Suki should own, then follow the matching path for Ambient, Dictation, Form filling, or Patient Summary.

Refer to the Integration paths overview for more information about the different workflows and how to choose the best integration method for your application.

Ambient Workflows

Integration choice

Goal: Select the best integration method for your application

Web SDK

Best for: React/JavaScript web apps that want Suki UI.

• Pre-built clinical UI components.
• Automatic state management.
• Fastest browser implementation.

Headless Web SDK

Best for: React 18+ web apps with a custom UI.

• Hooks for auth, sessions, and recording.
• You build all interface and layout.
• Same core ambient behavior as the Web SDK.

Mobile SDK

Best for: Native iOS applications.

• Optimized for mobile audio.
• Native performance.
• Offline capabilities.

Direct APIs

Best for: Custom implementations on any stack.

• Maximum flexibility.
• Any programming language.
• Full control at the API/WebSocket level.

Ambient Interoperability

Best for: Workflows that span Ambient APIs, Mobile SDK, Headless Web SDK, and Web SDK.

• Share one clinical note across modalities with emr_encounter_id, and reuse encounter_id for re-ambient sessions when provided.
• Continue or re-ambient from another supported product.
• Retrieve the latest note after Web SDK edits.

Time: 1-2 hours to evaluate options.

Integration implementation

Web SDK Path

Goal: Install and configure the Suki Web SDK

1. Install Package (15 Min)

   Install @suki-sdk/core plus @suki-sdk/react for React or @suki-sdk/js for plain JavaScript

   npm install @suki-sdk/react @suki-sdk/core
   

   Next: Initialize auth and the SDK client (see quickstart for your stack)

2. Basic Configuration (30 Min)

   Create SukiAuthManager from @suki-sdk/core with your partnerId, partnerToken, and provider fields. In React, wrap with SukiProvider and call init({ authManager }) from useSuki() in a child (once, usually from useEffect). In JavaScript, call initialize({ authManager }) from @suki-sdk/js.

   import { SukiProvider } from '@suki-sdk/react';
   
   function App() {
     return (
       <SukiProvider>
         {/* init({ authManager }) from useSuki() in a child */}
       </SukiProvider>
     );
   }
   

   Next: Mount the UI and start an ambient session

3. First Ambient Session (45 Min)

   Mount the SDK UI with an encounter and walk through recording and note generation

   What you’ll build: A simple flow that starts Ambient documentation, captures audio, and returns a clinical note

   Next: Test with sample audio and verify note generation

Web SDK quickstart →

Headless Web SDK Path

Goal: Install the Headless Web SDK and wire authentication and ambient hooks in React

1. Install Package (15 Min)

   Install the Headless Web SDK in a React 18+ project

   npm install @suki-sdk/platform-react
   

   Confirm your test and production host URLs are on the Suki allowlist (see Headless Web SDK prerequisites).

   Next: Add PlatformClient and PlatformClientProvider

2. Platform Client and Provider (20 Min)

   Create a PlatformClient and wrap your app with PlatformClientProvider (see Platform client and provider and Quickstart)

   import { PlatformClient, PlatformClientProvider } from '@suki-sdk/platform-react';
   
   const client = new PlatformClient({ env: 'staging', enableDebug: true, logLevel: 'error' });
   
   function App() {
     return (
       <PlatformClientProvider client={client}>
         <YourApp />
       </PlatformClientProvider>
     );
   }
   

   Next: Authenticate with useAuth inside the provider tree

3. Authentication Hooks (45 Min)

   Add the useAuth hook under the provider with your partnerId and partnerToken (see the Authentication hook guide)

   import { useAuth } from '@suki-sdk/platform-react';
   
   function YourApp() {
     const { isLoggedIn, isPending, error, login } = useAuth({
       partnerId: 'your-partner-id',
       partnerToken: 'your-partner-token',
       // See Authentication hook guide for full options
     });
     // Render your own sign-in UI and loading states
   }
   

   Next: Create an ambient session with useAmbient

4. Session and Recording (60 to 90 Min)

   Create a session with useAmbient, then use useAmbientSession for recording lifecycle and status

   What you’ll build: Your own controls and layout (start, pause, submit) backed by hook state, plus retrieval of note content when processing completes

   Next: Follow the quickstart through your first end-to-end recording, then harden error handling

   For step-by-step code, use the quickstart and Authentication hook, Ambient hook, and Ambient session hook guides.

Headless Web SDK quickstart →

Mobile SDK Path

Goal: Install and configure the Suki Mobile SDK

1. Install Framework (20 Min)

   Download SukiAmbientCore.framework, add it to your Xcode project, set Embed & Sign, and add NSMicrophoneUsageDescription to Info.plist

   Next: Set the environment and initialize the SDK

2. Basic Configuration (45 Min)

   Import SukiAmbientCore, set SukiAmbientCoreManager.shared.environment, then call initialize with partner info, session delegate, and token provider

   import SukiAmbientCore
   
   SukiAmbientCoreManager.shared.environment = .stage
   
   try SukiAmbientCoreManager.shared.initialize(
       withPartnerInfo: partnerInfo,
       with: true,
       onCompletion: { result in
           // Handle initialization result
       },
       withSessionDelegate: self,
       withTokenProvider: self
   )
   

   Next: Implement session management (see Configuration)

3. First Ambient Session (60 Min)

   Create a basic ambient session with recording capabilities

   What you’ll build: A view controller that can create sessions, record audio, and retrieve generated notes

   Next: Test with device microphone and verify functionality

Mobile SDK installation →

Ambient APIs Path

Goal: Implement Ambient APIs directly in your application

1. Authentication Implementation (60 Min)

   Implement the authentication flow to get Suki tokens

   Key endpoints: /api/v1/auth/register, /api/v1/auth/login

   Next: Test token generation and validation

2. Session Management (90 Min)

   Implement ambient session creation, context, and completion

   Key endpoints:

   • POST /api/v1/ambient/session/create - Create session.
   • POST /api/v1/ambient/session/{ambient_session_id}/context - Set context.
   • POST /api/v1/ambient/session/{ambient_session_id}/end - End session.

   Next: Stream visit audio on the Partner WebSocket

3. Audio Streaming (90 Min)

   Stream visit audio on the Partner WebSocket using your ambient session ID

   Connection: wss:// to GET /ws/stream (see Ambient audio streaming)

   Next: Poll status or configure a webhook, then retrieve content

4. Content Retrieval (45 Min)

   Implement note generation monitoring and content retrieval

   Key endpoints:

   • GET /api/v1/ambient/session/{ambient_session_id}/status - Check status.
   • GET /api/v1/ambient/session/{ambient_session_id}/content - Get generated note.

   Next: Test end-to-end workflow

API overview →

Dictation Workflows

Integration choice

Goal: Select the best integration method for Dictation in your application

Web SDK

Best for: Apps that already use (or prefer) the Web SDK packages.

• Dictation client and components ship in @suki-sdk/js and @suki-sdk/react.
• No separate Dictation SDK install.
• Same in-field and scratchpad modes as the Dictation SDK.

Dictation SDK

Best for: Browser apps that need hosted Dictation without the full Web SDK.

• Standalone @suki-sdk/dictation / @suki-sdk/dictation-react packages.
• Hosted Dictation iframe in your page.
• In-field and scratchpad modes.

Dictation APIs

Best for: Custom web, mobile, or backend integrations that own the transcript UI.

• REST session lifecycle and Partner WebSocket transcripts.
• Any stack, including native mobile (Dictation SDK and Web SDK Dictation are browser-only).
• Full control at the API/WebSocket level.

Prerequisites: Partner ID and working authentication from Foundation setup (Steps 1–2).

Time: 1-2 hours to evaluate options and read the decision guide.

Integration implementation

Web SDK Path

Goal: Add Dictation with the Web SDK packages (no standalone Dictation SDK install)

1. Install Package (15 Min)

   Install @suki-sdk/core plus @suki-sdk/react for React or @suki-sdk/js for plain JavaScript. Dictation is included in these packages.

   npm install @suki-sdk/react @suki-sdk/core
   

   Confirm your app meets Web SDK prerequisites.

   Next: Create SukiAuthManager and DictationClient once per page

2. Basic Configuration (30 Min)

   Create SukiAuthManager from @suki-sdk/core. Create DictationClient from @suki-sdk/react (or @suki-sdk/js). In React, wrap with DictationProvider and reuse the same client with useMemo.

   import { useMemo } from 'react';
   import { SukiAuthManager } from '@suki-sdk/core';
   import { DictationClient, DictationProvider } from '@suki-sdk/react';
   
   const client = useMemo(() => {
     const authManager = new SukiAuthManager({
       partnerId: 'YOUR_PARTNER_ID',
       partnerToken: 'YOUR_PARTNER_TOKEN',
       environment: 'staging',
       loginOnInitialize: true,
     });
     return new DictationClient({ authManager });
   }, []);
   

   Next: Mount Dictation for an in-field or scratchpad session

3. First Dictation Session (45 Min)

   Call client.show() or render <Dictation> with a stable fieldId and your target field or scratchpad layout.

   What you’ll build: A simple flow that opens hosted Dictation from the Web SDK, streams speech-to-text, and returns transcript text through SDK callbacks

   Next: Test in-field and scratchpad modes, then wire results into your chart fields

   For step-by-step code, use Web SDK for Audio Dictation and the React or JavaScript guide.

Web SDK for Audio Dictation →

Dictation SDK Path

Goal: Install and configure the Dictation SDK in a React or JavaScript web application

1. Install Package (15 Min)

   Install @suki-sdk/core plus @suki-sdk/dictation-react for React or @suki-sdk/dictation for plain JavaScript

   npm install @suki-sdk/dictation-react @suki-sdk/core
   

   Confirm your test and production host URLs are on the Suki allowlist (see Dictation SDK prerequisites).

   Next: Create SukiAuthManager and DictationClient once per page

2. Basic Configuration (30 Min)

   Create SukiAuthManager from @suki-sdk/core with your partnerId, partnerToken, and provider fields. Create DictationClient with that auth manager. In React, wrap with DictationProvider and reuse the same client with useMemo.

   import { useMemo } from 'react';
   import { SukiAuthManager } from '@suki-sdk/core';
   import { DictationClient } from '@suki-sdk/dictation';
   import { DictationProvider } from '@suki-sdk/dictation-react';
   
   const client = useMemo(() => {
     const authManager = new SukiAuthManager({
       partnerId: 'YOUR_PARTNER_ID',
       partnerToken: 'YOUR_PARTNER_TOKEN',
       environment: 'staging',
       loginOnInitialize: true,
     });
     return new DictationClient({ authManager });
   }, []);
   

   Next: Mount Dictation for an in-field or scratchpad session

3. First Dictation Session (45 Min)

   Give Dictation a target field or scratchpad container, then call client.show() or render <Dictation> with a stable fieldId and encounter.

   What you’ll build: A simple flow that opens hosted Dictation, streams speech-to-text, and returns transcript text through SDK callbacks

   Next: Test in-field and scratchpad modes, then wire results into your chart fields

   For step-by-step code, use the quickstart and Configuration guide.

Dictation SDK quickstart →

Dictation APIs Path

Goal: Implement Dictation REST APIs and the Partner WebSocket transcript stream in your application

1. Authentication Implementation (60 Min)

   Implement the authentication flow to get Suki tokens for Dictation REST and WebSocket calls

   Key endpoints: /api/v1/auth/register, /api/v1/auth/login

   Next: Test token generation and create a transcription session

2. Session Lifecycle (75 Min)

   Create a Dictation (transcription) session, stream audio, then end the session

   Key endpoints:

   • POST /api/v1/transcription/session/create - Create session.
   • GET /ws/transcribe - Stream audio and receive transcript frames.
   • POST /api/v1/transcription/session/{transcription_session_id}/end - End session.

   Next: Render interim and final transcript text in your own UI

   For streaming details, see Stream Dictation audio and Dictation streaming transcripts.

3. Own the Transcript UX (45 Min)

   Map transcript frames into chart fields, editors, or scratchpad UI in your application

   What you’ll build: An end-to-end flow from login through live transcript display in your own controls

   Next: Test desktop and mobile clients, then harden mic permissions and error handling

Dictation create session →

Form Filling Workflows

Integration choice

Goal: Select the best integration method for Form filling in your application

Web SDK

Best for: Apps that already use (or prefer) the Web SDK packages.

• Form filling client and components ship in @suki-sdk/js and @suki-sdk/react (v3.2.0+).
• No separate Form filling SDK install.
• Hosted Form filling UI with SDK callbacks and Partner webhooks.

Form Filling SDK

Best for: React or JavaScript web apps that want Form filling without the full Web SDK.

• Standalone @suki-sdk/form-filling / @suki-sdk/form-filling-react packages.
• Hosted Form filling UI in your page.
• SDK callbacks and Partner webhook delivery.

Mobile SDK

Best for: Native iOS apps that already use SukiAmbientCore.

• Headless Form filling with sessionType: .formFilling (v2.9.0+).
• You own the recorder and form review UI.
• Same XOR form context contract as Form filling APIs.

Form Filling APIs

Best for: Custom web, mobile, or backend integrations.

• REST session lifecycle and structured form output.
• Shared Partner WebSocket for visit audio.
• You build template selection, capture, and review UI.

Prerequisites: Partner ID and working authentication from Foundation setup (Steps 1–2).

Time: 1-2 hours to evaluate options and read the decision guide.

Integration implementation

Web SDK Path

Goal: Add Form filling with the Web SDK packages (no standalone Form filling SDK install)

1. Install Package (15 Min)

   Install @suki-sdk/core plus @suki-sdk/react for React or @suki-sdk/js for plain JavaScript. Use Web SDK v3.2.0 or later so Form filling is included.

   npm install @suki-sdk/react @suki-sdk/core
   

   Work with Suki’s Support team to get template_id UUIDs for static forms entries (or define partner schema objects for dynamic forms).

   Next: Create SukiAuthManager and FormFillingClient once per page

2. Basic Configuration (30 Min)

   Create SukiAuthManager from @suki-sdk/core. Create FormFillingClient from @suki-sdk/react (or @suki-sdk/js). In React, wrap with FormFillingProvider and reuse the same client with useMemo.

   import { useMemo } from 'react';
   import { SukiAuthManager } from '@suki-sdk/core';
   import { FormFillingClient, FormFillingProvider } from '@suki-sdk/react';
   
   const client = useMemo(() => {
     const authManager = new SukiAuthManager({
       partnerId: 'YOUR_PARTNER_ID',
       partnerToken: 'YOUR_PARTNER_TOKEN',
       environment: 'staging',
       loginOnInitialize: true,
     });
     return new FormFillingClient({ authManager });
   }, []);
   

   Next: Open a Form filling session with forms and correlation_id

3. First Form Filling Session (45 Min)

   Give Form filling a container with explicit height, then call client.start() or render <FormFilling> with your template IDs and encounter ID as correlation_id.

   What you’ll build: A simple flow that opens the hosted Form filling UI from the Web SDK, captures visit conversation by voice, and returns structured form output through onSubmit and your Partner webhook

   Next: Test with a supported Medical form template and verify structured output

   For step-by-step code, use Web SDK for Form filling and the React or JavaScript guide.

Web SDK for Form filling →

Form Filling SDK Path

Goal: Install and configure the Form filling SDK in a React or JavaScript web application

1. Install Package (15 Min)

   Install @suki-sdk/core plus @suki-sdk/form-filling-react for React or @suki-sdk/form-filling for plain JavaScript

   npm install @suki-sdk/form-filling-react @suki-sdk/core
   

   Work with Suki’s Support team to get template_id UUIDs for static forms entries (or define partner schema objects for dynamic forms).

   Next: Create SukiAuthManager and FormFillingClient once per page

2. Basic Configuration (30 Min)

   Create SukiAuthManager from @suki-sdk/core with your partnerId, partnerToken, and provider fields. Create FormFillingClient with that auth manager. In React, wrap with FormFillingProvider and reuse the same client with useMemo.

   import { useMemo } from 'react';
   import { SukiAuthManager } from '@suki-sdk/core';
   import { FormFillingClient, FormFillingProvider } from '@suki-sdk/form-filling-react';
   
   const client = useMemo(() => {
     const authManager = new SukiAuthManager({
       partnerId: 'YOUR_PARTNER_ID',
       partnerToken: 'YOUR_PARTNER_TOKEN',
       environment: 'staging',
       loginOnInitialize: true,
     });
     return new FormFillingClient({ authManager });
   }, []);
   

   Next: Open a Form filling session with forms and correlation_id

3. First Form Filling Session (45 Min)

   Give Form filling a container with explicit height, then call client.start() or render <FormFilling> with your template IDs and encounter ID as correlation_id.

   What you’ll build: A simple flow that opens the hosted Form filling UI, captures visit conversation by voice, and returns structured form output through onSubmit and your Partner webhook

   Next: Test with a supported Medical form template and verify structured output

   For step-by-step code, use the quickstart and Configuration and Session workflow guides.

Form filling SDK quickstart →

Mobile SDK Path

Goal: Run Form filling on iOS with the Mobile SDK (SukiAmbientCore)

1. Install and Configure (30 Min)

   Install and configure the Mobile SDK the same way as for Ambient. Use Mobile SDK v2.9.0 or later.

   Refer to Installation and Configuration.

   Work with Suki’s Support team to get template_id UUIDs for static entries, or prepare partner schema JSON for dynamic forms.

   Next: Create a Form filling session

2. Create Form Filling Session (30 Min)

   Call createSession with sessionType: .formFilling and optional kCorrelationId. Store recordingId.

   SukiAmbientCoreManager.shared.createSession(
       with: [SukiAmbientConstant.kCorrelationId: appointmentId],
       sessionType: .formFilling
   ) { result in
       // Store response.recordingId
   }
   

   Next: Set form context and record

3. Context, Record, Retrieve (60 Min)

   Call setFormFillingContext with form_filling.values (static and/or dynamic). On iOS, dynamic schema must be a JSON object string. Then start / pause / resume, endFormFillingSession(), and getFormFillingStructuredData(for: recordingId).

   What you’ll build: A headless Form filling flow where your app owns the recorder and form review UI, and Suki returns generatedValues / nonGeneratedValues

   Next: Match dynamic rows with partnerFormId, show non-generated templates as not filled

   For the full contract, use Form filling on Mobile SDK.

Form filling on Mobile SDK →

Form Filling APIs Path

Goal: Implement Form filling REST APIs and the shared Partner WebSocket in your application

1. Authentication Implementation (60 Min)

   Implement the authentication flow to get Suki tokens for Form filling REST calls

   Key endpoints: /api/v1/auth/register, /api/v1/auth/login

   Next: Test token generation and call Form filling session APIs with sdp_suki_token

2. Session and Context (75 Min)

   Create a Form filling session and seed template context before audio capture (required to generate filled forms)

   Key endpoints:

   • POST /api/v1/form-filling/session/create - Create session.
   • POST /api/v1/form-filling/session/{ambient_session_id}/context - Bind form_template_id values.

   The session ID field is named ambient_session_id, but it is not the same ID as an Ambient API session. Use only the value returned from Form filling /session/create for Form filling REST and for /ws/stream.

   Next: List templates if needed, then open the audio WebSocket

3. Audio Streaming (90 Min)

   Stream visit audio on the Partner WebSocket using your Form filling session ID

   Connection: wss:// to GET /ws/stream (same wire format as ambient; see Ambient audio streaming)

   Sequence: START_TIME, AUDIO chunks (Base64 PCM), AUDIO with EOF (RU9G), close the WebSocket, then call session end on REST

   Next: Poll status or configure a webhook for completion

4. Structured Output (45 Min)

   End the session, monitor processing, and retrieve populated form fields

   Key endpoints:

   • POST /api/v1/form-filling/session/{ambient_session_id}/end - End session.
   • GET /api/v1/form-filling/session/{ambient_session_id}/status - Check status.
   • GET /api/v1/form-filling/session/{ambient_session_id}/structured-data - Get generated_values and non_generated_values.

   Optional: Webhook notifications when processing finishes

   What you’ll build: An end-to-end flow from login through structured form output in your UI or downstream systems

   Next: Test in-person and virtual scenarios, then harden error handling

Form filling API quickstart →

Patient Summary Workflows

Integration choice

Goal: Select how to integrate Patient Summary for pre-visit workflows in your application

Web SDK

Best for: Apps that already embed the headed Web SDK patient profile.

• Hosted pre-visit snippet and full summary in the Web SDK UI (v3.3.0+).
• No Patient Summary generate, status, or retrieve calls from your UI code.
• CKG FHIR ingestion still required on your backend.

Patient Summary APIs

Best for: Custom web, mobile, or backend integrations that own schedule and chart UI.

• Upload FHIR data into Suki’s Clinical Knowledge Graph (CKG).
• Trigger asynchronous generation for a schedule or a single encounter.
• Retrieve full and pre-visit summaries for clinical review in your own UI.

Both paths require CKG ingestion. The headed Web SDK owns the Patient Summary UI inside the iframe. Custom applications use the Patient Summary APIs and render summary sections themselves.

Prerequisites: Partner ID and working authentication from Foundation setup (Steps 1–2), including Login to obtain an sdp_suki_token for CKG ingestion.

Time: 1-2 hours to evaluate options and read the decision guide.

Integration implementation

Web SDK Path

Goal: Show Patient Summary on the headed Web SDK patient profile

1. Upgrade Web SDK (15 Min)

   Use Web SDK v3.3.0 or later (@suki-sdk/js or @suki-sdk/react with @suki-sdk/core)

   npm install @suki-sdk/react @suki-sdk/core
   

   Ask Suki Technical Support to enable Patient Summary for your organization.

   Next: Ingest FHIR into CKG from your backend

2. CKG FHIR Ingestion (75 Min)

   Your backend still owns CKG ingestion with the Patient Summary CKG Data Ingestion APIs. Keep fhir_encounter_id and fhir_practitioner_id consistent with the ids you pass to the Web SDK.

   Key endpoints:

   • GET /api/v1/fhir-push/upload-url - Request upload URL.
   • PUT /api/v1/fhir-push/upload - Upload FHIR bundle.
   • GET /api/v1/fhir-push/status/{transaction_id} - Check ingestion status.

   Next: Pass matching encounter context when you initialize and mount the Web SDK

3. Pass Encounter Context (45 Min)

   When you initialize and mount, pass matching encounter.identifier (FHIR encounter id), encounter.practitionerFhirId (FHIR practitioner id), and encounter.patient. Generation runs at login from the initialize options. The patient profile shows the snippet and full summary in the Web SDK UI.

   What you’ll build: A headed Web SDK flow where clinicians open the patient profile and review pre-visit summary without calling generate, status, or retrieve APIs from your UI

   Next: Test with ingested FHIR data, then confirm empty states when ids do not match

   For step-by-step guidance, use Patient Summary in Web SDK.

Patient Summary in Web SDK →

Patient Summary APIs Path

Goal: Implement Patient Summary REST APIs for CKG ingestion, summary generation, and retrieval

1. Authentication Implementation (60 Min)

   Implement the authentication flow to get an sdp_suki_token for Patient Summary REST calls and CKG Data Ingestion

   Key endpoints: /api/v1/auth/register, /api/v1/auth/login

   Next: Test Login, then request a CKG upload URL with the same sdp_suki_token

2. CKG FHIR Ingestion (75 Min)

   Request an upload URL, upload a FHIR R4 bundle, and poll ingestion status until CKG processing completes

   Key endpoints:

   • GET /api/v1/fhir-push/upload-url - Request upload URL.
   • PUT /api/v1/fhir-push/upload - Upload FHIR bundle.
   • GET /api/v1/fhir-push/status/{transaction_id} - Check ingestion status.

   Keep fhir_encounter_id and fhir_practitioner_id consistent between the ingested FHIR resources and later generation or retrieval calls. Do not trigger summary generation while ingestion is still running.

   Next: Trigger summary generation for an encounter or a provider schedule

3. Summary Generation (60 Min)

   Enqueue asynchronous Patient Summary generation for a single encounter or a provider’s scheduled appointments

   Key endpoints:

   • POST /api/v1/patient-summary/generate/encounter - Generate for one encounter.
   • POST /api/v1/patient-summary/generate/provider-schedule - Generate for a schedule batch.

   Next: Poll job status until generation completes

4. Status and Retrieval (45 Min)

   Poll generation status, then retrieve the full Patient Summary or pre-visit section for your schedule or chart UI

   Key endpoints:

   • GET /api/v1/patient-summary/{patient_summary_id}/status - Check job status.
   • GET /api/v1/patient-summary/{patient_summary_id} - Get full summary.
   • GET /api/v1/patient-summary/{patient_summary_id}/pre_visit - Get pre-visit summary.

   What you’ll build: An end-to-end flow from FHIR upload through pre-visit summary display in your schedule, chart, or patient-profile UI

   Next: Test morning clinic preparation and on-demand encounter scenarios, then harden empty states and error handling

   For step-by-step guidance, use the quickstart and Generate Patient Summaries and Retrieve Patient Summaries guides.

Patient Summary API quickstart →

---

Advanced features

Estimated Time: 1-2 weeks

Step 4: Add advanced capabilities

Goal: Enhance your integration with Suki’s advanced features

Multilingual Support

Time: 2-3 hours.

Enable support for 80+ languages with automatic English note generation.

Key Features:

• Automatic language detection.
• Multi-language conversations.
• English output standardization.

Learn more

Problem-Based Charting

Time: 4-6 hours.

Implement diagnosis-focused documentation structure.

Key Features:

• Problem-oriented notes.
• Diagnosis tracking.
• Enhanced clinical workflows.

Learn more

Custom Note Sections

Time: 2-4 hours.

Configure custom clinical note sections using LOINC codes.

Key Features:

• 26+ standard sections.
• Custom section ordering.
• EHR integration ready.

Learn more

User Preferences

Time: 3-5 hours.

Allow providers to customize their documentation preferences.

Key Features:

• Personal note styling.
• Section preferences.
• Workflow customization.

Learn more

Ambient Interoperability

Time: 3-5 hours.

Share one clinical note across Ambient APIs, Mobile SDK, Headless Web SDK, and Web SDK.

Key Features:

• Continue or re-ambient across modalities.
• Stable emr_encounter_id and reusable encounter_id.
• Retrieve the latest note after Web SDK edits.

Learn more

---

Production readiness

Estimated Time: 1 week

Step 5: Testing and optimization

Goal: Ensure your integration is production-ready

What You Will Do

• Comprehensive testing with real clinical scenarios.
• Performance optimization and error handling.
• Security review and compliance verification.
• User acceptance testing with healthcare providers.

Key areas:

• Audio quality and streaming reliability.
• Note generation accuracy and speed.
• Error handling and recovery.
• HIPAA compliance verification.

Time: 3-5 days.

Step 6: Go live

Goal: Deploy your Suki-powered application to production

Production Deployment

• Switch to production environment.
• Monitor initial usage and performance.
• Gather user feedback and iterate.
• Scale based on usage patterns.

Support resources:

• 24/7 technical support during launch.
• Performance monitoring and alerts.
• Regular check-ins with Suki team.

Next steps

Quickstart - Build the minimum path for your workflow.

Integration paths overview - Choose the right SDK or API mix.

Available workflows - If you still need to pick Ambient, Dictation, Form filling, or Patient Summary.

Support - Staging validation and production support options.