Introducing rakedoc-nano: a state-of-the-art open-weight VLM for document parsing

Medical scribe, built into your product.

Turn consultations and clinical calls into structured documentation, without adding another app to the clinician's day. CloudRaker is the infrastructure. The experience stays inside the product your users already open.

The problem

The conversation already holds the record.

A consultation contains everything the clinical record needs. Someone still has to turn it into documentation. That means listening again, typing, summarizing, copying, checking, and moving the result into the right system.

Nobody became a clinician because they love typing notes. At one call a day it is an annoyance. At a few thousand a month it is infrastructure, and it belongs in the product, not in a person's evening.

CloudRaker is not a scribe you install. It is what you build one on.

The workflow

Conversation in. Structured note out.

Five stages. One of them belongs to a person, and you decide which runs reach it.

InConsultation or callRecorded yesterday or streaming right now.
  1. Parse

    Transcribe the audio and separate the speakers. Every segment carries a start time, an end time, and a speaker label.

    processing: transcribe_diarizesegments[].speaker
  2. Extract

    Map the conversation onto the note structure you defined. Chief complaint, assessment, plan, follow-up, whatever your fields are.

    POST /v1/extractaction: medical-scribe
  3. Ground and score

    Each field points back at the timecode it came from. A second pass judges the first and returns a score from 0 to 5.

    citations: trueconfidence: 0-5
  4. Review

    A person edits, comments, assigns, and approves. Send everything at 3 or below here, or everything, or nothing. Your rule.

    confidence <= 3approval logged
  5. Send

    Structured JSON goes back to whatever asked for it. Poll the run, or take the webhook and skip the polling.

    GET /v1/runs/:idwebhook
OutStructured noteJSON your EMR, portal, or case system can accept.
The demo

Six minutes, one call, no slides.

Defining the fields, uploading the recordings, watching the run, checking a value against the transcript, and approving it. This is the workspace doing the work — the same thing your product can do over the API.

Recorded against a working environment, so the rough edges are in it.Open in a new tab
Configuration

Make the note yours.

CloudRaker does not ship a clinical note. You define the fields, add instructions where they matter, and save the configuration under a name. Every later call references that name instead of repeating the schema. Change the note in one place, not in every caller's source. POST it to /v1/extract/configs and you get back a slug.

JSON
{
  "name": "Medical scribe",
  "config": {
    "grounding": true,
    "instructions": "Stay factual. Use only what was said.",
    "schema": {
      "type": "object",
      "properties": {
        "chief_complaint": { "type": ["string", "null"] },
        "symptoms":        { "type": "array", "items": { "type": "string" } },
        "assessment":      { "type": "array", "items": { "type": "string" } },
        "plan":            { "type": "array", "items": { "type": "string" } },
        "follow_up":       { "type": ["string", "null"] },
        "flag_caller":     { "type": ["boolean", "null"] }
      }
    }
  }
}
Human review

Let AI draft. Let people decide.

Not every workflow needs an approval step. Not every workflow is safe without one. The step is configurable, which is the only honest answer.

  • Who decides
    What people assume The model writes the note and the note becomes the record.
    What happens Every AI-written field starts as a draft. A person with the right access edits it, approves it, and the approval is logged against their name.
  • Where it came from
    What people assume You trust the summary, or you replay the whole recording.
    What happens Turn grounding on and every field carries the transcript segment and the timecode it came from. Verifying one value costs one click, not eleven minutes.
  • When it is unsure
    What people assume A confident-sounding sentence fills the silence, and nobody finds out.
    What happens A second pass scores the first from 0 to 5. Route 3 and below to a person. A low score never rewrites the value — it only tells your routing code where to look.
  • After an edit
    What people assume Once a human touches it, the trail goes cold.
    What happens Editing an AI-written value replaces it with your text and drops its citation, because the value no longer came from the transcript. The record stays honest about who wrote what.
Surfaces

Your scribe. Your product.

Nobody has to log into CloudRaker for this to work. The Workspace is there when a team wants a place to review. It is not a requirement.

The application you already ship
The note appears in your UI, in your layout, under your name. CloudRaker runs behind it and your users never learn it exists.
Telehealth and call centres
Live calls, queued recordings, or both. The same extraction runs over a consultation and over an intake call.
Patient portals
A structured summary is easier to show a patient than a transcript. You choose which fields they see.
The API
One REST call per capability, or one pipeline call for several at once. No SDK required, though there is one.
See the API
The Workspace
For the team that reviews rather than builds. Records, per-field approvals, comments, and access rights, without a UI to write.
See the Workspace
An agent
Claude, or anything else that speaks MCP, can run the same capabilities as a tool. Same schema, same citations, same scores.
See the agent tools
Getting the audio in

Recorded yesterday or streaming right now.

The audio arrives however your product already produces it. The workflow after it does not change.

Uploaded recordings
Register the file, PUT the bytes to the presigned URL, wait for status ready. The platform parses it once and never re-parses it.
Audio your app already has
Pass a URL instead of bytes. If your product already stores the recording, CloudRaker can fetch it from there.
SIP and WebSocket streams
We run SIP for live call audio in our own call centre workload, and WebSockets when a stream needs to reach the platform directly. Talk to us about wiring either one.
Talk to us
A plain API call
POST /v1/extract with a file id and a saved config name. Two fields. That is the whole request for a note.
Batches
Up to 100 files in one pipeline call. Files are parsed once and shared across every step, and the steps run in parallel.
Without the polling
Attach a webhook and wait for the completed event. Or long-poll the run for up to 120 seconds. Or just poll. All three are fine.
For the engineers in the room

Build it into the stack you already have.

Four calls. Your product keeps the user, the UI, and the data. CloudRaker does the part nobody wants to build twice.

  1. 01

    Register the audio

    POST the file record with processing set to transcribe_diarize, then PUT the bytes to the upload URL you get back. That URL is good for fifteen minutes. Poll the file until its status is ready.

    POST /v1/filesprocessing: transcribe_diarizeGET /v1/files/:id
  2. 02

    Run the extraction you saved

    Reference the saved config by name. Send inline fields alongside it when one batch needs an override — inline wins, and the merge is a deep one, so you are not copying the schema to change one instruction.

    POST /v1/extractaction: medical-scribecitations: true
  3. 03

    Read the fields and the receipts

    The response carries your fields and, on a grounded run, a citation per field with the timecode and the quoted transcript segment. Timecodes are segment-level. Need tighter than that, read the words array on the transcript JSON.

    outputcitations[].timecodeurls.json
  4. 04

    Decide what happens to the run

    Runs are ephemeral. The default TTL is 24 hours and the ceiling is 7 days. Delete one early to purge it now, or keep it to promote its files and results into a permanent space with the clock removed.

    ttl: 1-604800DELETE /v1/runs/:idPOST /v1/runs/:id/keep
The whole thing

Audio in, note out, in one file.

Upload, wait, extract, read the citations. Nothing else is hiding behind this.

const key = process.env.CLOUDRAKER_API_KEY!
const headers = {Authorization: `Bearer ${key}`, 'Content-Type': 'application/json'}

// 1. Reserve the record. transcribe_diarize gives us speaker labels.
const file = await fetch('https://api.cloudraker.com/v1/files', {
  method: 'POST',
  headers,
  body: JSON.stringify({
    name: 'intake-call-0311.m4a',
    mimeType: 'audio/mp4',
    processing: 'transcribe_diarize',
  }),
}).then((r) => r.json())

// 2. Send the bytes to the presigned URL. Good for 15 minutes.
await fetch(file.uploadUrl, {
  method: 'PUT',
  headers: {'Content-Type': 'audio/mp4'},
  body: audioBytes,
})

// 3. Wait for the transcript, then run the note you saved earlier.
await waitUntilReady(file.id)
const run = await fetch('https://api.cloudraker.com/v1/extract', {
  method: 'POST',
  headers,
  body: JSON.stringify({
    file: {id: file.id},
    action: 'medical-scribe',
    citations: true,
  }),
}).then((r) => r.json())

// 4. Every field knows where it came from.
console.log(run.output.chief_complaint)
console.log(run.output.citations.chief_complaint[0].timecode) // 12.4
import os, requests

API = "https://api.cloudraker.com/v1"
headers = {"Authorization": f"Bearer {os.environ['CLOUDRAKER_API_KEY']}"}

# 1. Reserve the record. transcribe_diarize gives us speaker labels.
file = requests.post(
    f"{API}/files",
    headers=headers,
    json={
        "name": "intake-call-0311.m4a",
        "mimeType": "audio/mp4",
        "processing": "transcribe_diarize",
    },
).json()

# 2. Send the bytes to the presigned URL. Good for 15 minutes.
requests.put(
    file["uploadUrl"],
    headers={"Content-Type": "audio/mp4"},
    data=audio_bytes,
)

# 3. Wait for the transcript, then run the note you saved earlier.
wait_until_ready(file["id"])
run = requests.post(
    f"{API}/extract",
    headers=headers,
    json={
        "file": {"id": file["id"]},
        "action": "medical-scribe",
        "citations": True,
    },
).json()

# 4. Every field knows where it came from.
print(run["output"]["chief_complaint"])
print(run["output"]["citations"]["chief_complaint"][0]["timecode"])  # 12.4
After the note

The note is step one, not the finish line.

A dedicated scribe stops when the note is written. The same structured output can start the next piece of work instead.

Redact before it travels
Strip identifiers out of a transcript before it reaches a system that should not hold them. Targeted categories, not a blanket sweep.
See Redact
Fill the form it triggers
A referral, a requisition, a claim form. The fields you extracted are already the fields the form wants.
See Fill
Compose the document
Generate a letter, a summary, or a handoff from the structured result rather than from the raw transcript.
See Compose
Collect the signature
Send the finished document for signing without leaving the run it came from.
See Sign
Cut a long recording up
An hour-long call covers four subjects with four owners. Split gives each one its own addressable file.
See Split
Keep the run and make a case
Runs expire by default. Keep one and it becomes a real record in a space, indexed and searchable, ready for the next stage to claim.
Governance

Choose where processing happens and how long data stays around.

These are settings, not a sales conversation. The ones that need a conversation are marked as such.

Region and residency
CloudRaker is regionally hosted with configurable data residency. Which region a workload runs in is a platform setting, not a rewrite. Tell us the constraint you are under and we will tell you plainly whether we meet it.
See the trust centre
Retention you set
A run's TTL defaults to 24 hours and tops out at 7 days. Delete a run to purge its files and outputs immediately. Nothing accumulates in your spaces unless you explicitly keep it.
Who can see and who can approve
Organization roles decide who administers. Per-space roles decide who reads, contributes, manages, or archives inside a given space. Org membership on its own grants nothing.
Runs you can explain later
A kept run snapshots the configuration it ran with, so changing the note tomorrow does not rewrite what happened today. Citations, scores, and approvals stay attached to the output.
In production

This one is already running.

A leading Canadian telehealth provider runs this workload on CloudRaker. An AI agent answers incoming patient calls, routes them to the right service, and hands off to a human agent when someone needs more help — with the full transcript, a generated case summary, a case created in their own system, and notes transcribed for later reference.

Their health practitioners tested CloudRaker's call transcription head to head against a dedicated medical scribe product and found CloudRaker's notes more accurate. CloudRaker won that evaluation and the contract.

If you want a finished scribe to install this week, buy one. This page is for the team building the product around it. The full build-versus-buy comparison is in the journal.

Capabilities used

The building blocks under this one.

Four capabilities carry the workflow above. The rest of the library is there when the note turns into something else.

Parse
Transcribe the audio and separate the speakers. Word-level timings, speaker labels per segment, and the file is parsed exactly once.
Parse docs
Extract
Map the conversation onto your JSON Schema. Nullable fields let it report absence instead of guessing.
Extract docs
Grounding
Citations on. Each field comes back with the timecode and the quoted segment behind it.
Citations docs
Scoring
A 0 to 5 integer on the result. Four and up is the auto-process band. Three and below is where a person belongs.
Confidence docs
Related workflows

Same template. Different paperwork.

Anything where a conversation or a document has to become structured data that somebody reviews. These are next.

Medical intakeForms, faxes, and referral letters into the same structured record, with the same field-level review.
Call centre documentationEvery call leaves a summary, a disposition, and a case, without an agent typing after hangup.
Claims processingA claim packet split into its pieces, extracted, scored, and routed to the adjuster who owns it.
Care-team handoffThe note becomes a case, the case gets claimed, and the handoff notes are drafted from the instructions you wrote.
Prior authorizationAssemble the request from the chart, validate it against the payer's rules, and stop when a field will not validate.
Contract reviewSame shape, no audio. Clauses extracted, cited to the page, and flagged where the language drifts from your standard.
Start here

Your product already has the conversation. Now make it useful.

Get a key, save a note schema, and send it one recording. If it does not do what this page says, tell us and we will fix the page or the product.