Path 4 — Fully inline dynamic template

Define the template and every section inline in the request body — no prior authoring required. Ideal for prototyping or one-off generations.

Beta

← Back to Guided Synthesis overview

Use this for prototyping, one-off generations, or workflows where you don’t want to maintain stored sections. Define both the template instructions and each section’s full generation block inline. Sections and the wrapping template are created as auto-generated resources and immediately published — and like all auto-generated aggregates, are retained for 30 days only (see Auto-generated template aggregates — 30-day retention).

JavaScript

// Replace these with your values
const INTERACTION_ID = "<your-interaction-id>";

const result = await client.documents.generate({
  outputLanguage: "en-US",
  interactionId: INTERACTION_ID,
  dynamicTemplate: {
    name: "Allergy follow-up note (inline prototype)",
    generation: {
      instructions: { prompt: "Produce a focused allergy follow-up note." },
      sections: [
        {
          heading: "History of present illness",
          instructions: {
            contentPrompt: "Summarise the recent course of the patient's allergy symptoms.",
            writingStylePrompt: "Concise, professional.",
          },
          outputSchema: { type: "string" },
        },
        {
          heading: "Plan",
          instructions: {
            contentPrompt: "Outline next steps including any medication changes, testing or follow-up.",
          },
          outputSchema: {
            type: "array",
            itemFormat: "* {item}\n",
            maxItems: 5,
            items: { type: "string" },
          },
        },
      ],
    },
  },
});

using Corti;

// Replace these with your values
const string InteractionId = "<your-interaction-id>";

var result = await client.Documents.GenerateAsync(
    new GuidedDocumentsGenerateByDynamic
    {
        OutputLanguage = "en-US",
        InteractionId = InteractionId,
        DynamicTemplate = new GuidedDynamicRequest
        {
            Name = "Allergy follow-up note (inline prototype)",
            Generation = new GuidedDynamicInline
            {
                Instructions = new GuidedTemplateInstructions
                {
                    Prompt = "Produce a focused allergy follow-up note.",
                },
                Sections = new[]
                {
                    new GuidedSectionGeneration
                    {
                        Heading = "History of present illness",
                        Instructions = new GuidedSectionInstructions
                        {
                            ContentPrompt = "Summarise the recent course of the patient's allergy symptoms.",
                            WritingStylePrompt = "Concise, professional.",
                        },
                        OutputSchema = new GuidedStringNode(),
                    },
                    new GuidedSectionGeneration
                    {
                        Heading = "Plan",
                        Instructions = new GuidedSectionInstructions
                        {
                            ContentPrompt = "Outline next steps including any medication changes, testing or follow-up.",
                        },
                        OutputSchema = new GuidedArrayNode
                        {
                            ItemFormat = "* {item}\n",
                            MaxItems = 5,
                            Items = new GuidedStringNode(),
                        },
                    },
                },
            },
        },
    });

import requests

# Replace these with your values
ENVIRONMENT = "<eu-or-us>"
INTERACTION_ID = "<your-interaction-id>"
TENANT = "<your-tenant-name>"
TOKEN = "<your-access-token>"

response = requests.post(
    f"https://api.{ENVIRONMENT}.corti.app/v2/documents",
    headers={
        "Authorization": f"Bearer {TOKEN}",
        "Tenant-Name": TENANT,
        "Content-Type": "application/json",
    },
    json={
        "outputLanguage": "en-US",
        "interactionId": INTERACTION_ID,
        "dynamicTemplate": {
            "name": "Allergy follow-up note (inline prototype)",
            "generation": {
                "instructions": {"prompt": "Produce a focused allergy follow-up note."},
                "sections": [
                    {
                        "heading": "History of present illness",
                        "instructions": {
                            "contentPrompt": "Summarise the recent course of the patient's allergy symptoms.",
                            "writingStylePrompt": "Concise, professional.",
                        },
                        "outputSchema": {"type": "string"},
                    },
                    {
                        "heading": "Plan",
                        "instructions": {
                            "contentPrompt": "Outline next steps including any medication changes, testing or follow-up.",
                        },
                        "outputSchema": {
                            "type": "array",
                            "itemFormat": "* {item}\n",
                            "maxItems": 5,
                            "items": {"type": "string"},
                        },
                    },
                ],
            },
        },
    },
)
response.raise_for_status()
result = response.json()

# Replace these with your values
ENVIRONMENT="<eu-or-us>"
INTERACTION_ID="<your-interaction-id>"
TENANT="<your-tenant-name>"
TOKEN="<your-access-token>"

curl --request POST \
  --url "https://api.${ENVIRONMENT}.corti.app/v2/documents" \
  --header "Authorization: Bearer ${TOKEN}" \
  --header "Tenant-Name: ${TENANT}" \
  --header "Content-Type: application/json" \
  --data "{
    \"outputLanguage\": \"en-US\",
    \"interactionId\": \"${INTERACTION_ID}\",
    \"dynamicTemplate\": {
      \"name\": \"Allergy follow-up note (inline prototype)\",
      \"generation\": {
        \"instructions\": { \"prompt\": \"Produce a focused allergy follow-up note.\" },
        \"sections\": [
          {
            \"heading\": \"History of present illness\",
            \"instructions\": {
              \"contentPrompt\": \"Summarise the recent course of the patient's allergy symptoms.\",
              \"writingStylePrompt\": \"Concise, professional.\"
            },
            \"outputSchema\": { \"type\": \"string\" }
          },
          {
            \"heading\": \"Plan\",
            \"instructions\": {
              \"contentPrompt\": \"Outline next steps including any medication changes, testing or follow-up.\"
            },
            \"outputSchema\": {
              \"type\": \"array\",
              \"itemFormat\": \"* {item}\\n\",
              \"maxItems\": 5,
              \"items\": { \"type\": \"string\" }
            }
          }
        ]
      }
    }
  }"

Each inline sections[] entry is a full SectionGeneration — same shape you’d POST /documents/sections with. Use the full outputSchema toolbox (string, number, boolean, array, object with fields) to constrain output. See Section Schemas for design patterns.

Mapping response section IDs back to your inline sections — Path 4 gotcha

Path 4 is the one place where mapping response keys back to your request sections is non-trivial. Your request supplies an ordered list of SectionGeneration objects with no IDs of your own, but the response’s stringDocument / structuredDocument are keyed by server-generated section UUIDs. To attach the right heading to each rendered section:

1. Take the templateVersionId returned in the response.
2. Call GET /documents/templates/{templateId}/versions/{templateVersionId}.
3. The version’s sections[] array preserves your request order and carries the resolved section IDs. Build a position → sectionId → heading mapping from that response, then key the rendered output against it.

The auto-generated aggregate the follow-up GET reads is itself subject to the 30-day retention window. Do the mapping read soon after generation (typically in the same processing pass), or persist the mapping in your service.

This is a known DX gap for Path 4 specifically. The roadmap includes returning client-supplied identifiers (or section ordering) directly on the response so the follow-up GET isn’t needed.

When to use this path

Scenario	Why Path 4
Prototyping a new section or schema before promoting into your stored library	Iterate in one request; no authoring overhead.
One-off generation that doesn’t justify creating a section	Inline what you need; the auto-generated aggregate is your receipt.
Experiments on prompt + schema combinations	Run the same call with variations; compare outputs.

Related

Guided Synthesis overview

Shared concepts: input context, response shape, errors, 30-day retention.

Section Schemas

Schema patterns for the outputSchema shapes you’ll define inline.