# Example Workflow

### 1. Create a Document

First, create a document within your Domain using some initial data.

```typescript
import { Context } from '@contextprotocol/sdk';

const ctx = new Context({ apiKey: 'your_api_key_here' });

async function createDocument() {
    const data = {
        title: "Initial Document",
        content: "This is the initial content of the document."
    };

    const pathToFile = "myfiles/path/file_name";
    const document = await ctx.createDocument(pathToFile, data);
    if (!document.success) {
        // Handle error
    }
    console.log(`Document created on: ${document.data.path}`);

    return document;
}
```

### 2. Define and create a Template

Next, define a JSON schema and use it to create a new Template on your domain.

```typescript
async function createTemplate() {
    const schema = {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "type": "object",
        "properties": {
            "title": {
                "type": "string",
                "description": "The title of the document."
            },
            "content": {
                "type": "string",
                "description": "The content of the document."
            }
        },
        "required": ["title", "content"]
    };
    
    const templatePath = "templates/newtemplate";
    const template = await ctx.createTemplate(templatePath, schema);
    if (!template.success) {
        // Handle error
    }
    console.log(`Template created on: ${template.data.path}`);

    return template;
}
```

### 3. Update the Document

Then, update the previously created document to be adapted to the template.

```typescript
async function updateDocument(documentPath) {
    const updatedData = {
        title: "Updated Document",
        content: "This is the updated content of the document."
    };

    const doc = await ctx.document(documentPath)
    const updatedDoc = await doc.data.update(updatedData);
    if (!updatedDoc.success) {
        // Handle error
    }
    console.log(`Document updated with new data: ${updatedDoc.data.data}`);

    return updatedDoc;
}
```

### 3. Install the Template

Finally, install the created template.

```typescript
async function installTemplate(documentPath) {

    const doc = await ctx.document(documentPath)
    const updatedDoc = await doc.data.install(["your_domain/templates/newtemplate"]);
    if (!updatedDoc.success) {
        // Handle error
    }
    console.log(`Document updated with this templates: ${updatedDoc.data.templates}`);

    return updatedDoc;
}
```

Finally, update the previously created document with new data and apply the newly created template.

<br>


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.ctx.xyz/developers/example-workflow.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.