# Advanced Usage

> Your whole setup is Markdown on disk. Edit it in your own editor, put it under version control, and build workflows that chain several features together.

Source: https://triplo.ai/docs/advanced  
Last updated: 2026-10-18

## Files as configuration

Triplo AI stores nothing in a proprietary database. Every SmartPrompt, Instruction, Automation and conversation is a Markdown file in your Documents folder, and the app **watches those folders**.

Save a file in your editor and the change is live in Triplo within about half a second. No import, no restart, no sync button.

```
~/Documents/Triplo AI/
├── SmartPrompts/    # .md — watched, ~500 ms
├── Instructions/    # .md — watched, ~300 ms
├── Automations/     # .md — watched
├── History/         # .md — watched
├── Minds/           # folders — vault watched for re-indexing
└── Shared/          # read-only, written by sync
```

### What this unlocks

- **Bulk editing.** Rename a term across forty prompts with `sed`. Reorganise tags with a script.
- **Generation.** Emit prompt files from a template — one per client, one per product line.
- **Review.** Read your whole prompt library as text, in a diff, in a pull request.
- **Sharing without the sync system.** Send someone a `.md` file; they drop it in their folder and it appears.
- **Recovery.** Deleted something? Restore the file from git or Time Machine.

> **Tip:** Files whose name starts with `_` are ignored. Use that prefix for templates and notes you want to keep beside your prompts without Triplo loading them.

### Rules the watcher follows

- Only `.md` files are read.
- The **filename is the id**. Renaming a file makes a new item and removes the old one.
- Saves from the app are rate-limited to one per second per file.
- A file that fails to parse is skipped with a log entry — one bad file never breaks the rest.
- Editing in the app rewrites the whole file, so hand-added fields the format does not define will be lost on the next save from the UI.

## File formats

All four follow the same shape: a type header, a title, then sections separated by `---`. Settings are `**Key:** value` lines.

### SmartPrompt

```
# SMARTPROMPT
## Tighten

---

### Settings
**Active:** Yes
**Command:** tight
**Type:** normal
**Tags:** writing, editing

---

### Content
Rewrite the following text to be shorter and clearer
without losing any information.

Return only the rewritten text, with no commentary.

---

### Magnets
**Hotkey:** [Cmd+Shift+T]
**Model:** [connection-id:model-id]
**Instruction:** [instruction-id]
**Mind:** [mind-id]
**Automation:** [None]
```

| Field | Rules |
|---|---|
| Title (the `##` line) | Required, up to 200 characters |
| `Active` | `Yes` or `No` |
| `Command` | The trigger after `/` |
| `Tags` | Comma-separated, up to 10 |
| `### Content` | The template, up to 10,000 characters |
| Magnet fields | `[None]` or an id. Model is `connectionId:modelId`; allowance models use `__allowance__:modelId` |

Whole file limit: 50,000 characters.

### Instruction

```
# INSTRUCTION
## Backend engineer

---

### Settings
**Active:** Yes
**Tags:** work, code

---

### What
Senior backend engineer. Python and Go. Postgres, Redis...

---

### How
Lead with the answer, then the reasoning. Code first...
```

Title up to 100 characters, **What** up to 5,000, **How** up to 2,000. Both text sections are required. Files written by older versions using `### Context` and `### Response Style` are still read correctly.

### Automation

````
# AUTOMATION
## CreateTask

---

### Settings
**Active:** Yes

---

### Description
Creates a task in the engineering backlog.

---

### Parameters
- **title:** Imperative, under 80 characters.
- **priority:** One of low, medium, high, urgent.

---

### Endpoint
**URL:** https://api.example.com/tasks
**Method:** POST

#### Headers
```json
{ "Authorization": "Bearer YOUR_TOKEN" }
```

#### Payload
```json
{ "title": "{{title}}", "priority": "{{priority}}" }
```
````

Parameters are list items of the form `- **name:** description`. Headers and payload must be fenced `json` blocks and must parse.

### Vault notes

Notes inside a Mind use YAML frontmatter rather than this section format. See [Vault reference](https://triplo.ai/docs/training#vault-reference).

## Version-control your setup

Because it is all text, git works properly — real diffs, real history, real branches.

```
cd "~/Documents/Triplo AI"
git init
git add SmartPrompts Instructions
git commit -m "Prompt library"
```

### What to include

| Folder | Track it? | Why |
|---|---|---|
| `SmartPrompts/` | Yes | The main reason to do this |
| `Instructions/` | Yes | Small, valuable, worth diffing |
| `Automations/` | Careful | **Contains credentials in headers** |
| `Minds/` | Usually not | Large, and the vault is regenerated |
| `History/` | No | Grows without limit; often sensitive |
| `Shared/` | No | Rewritten by sync every pull |

```
# .gitignore
History/
Shared/
Minds/*/vault/
Minds/*/files/
Minds/*/failed/
Minds/*/index.md
Automations/
```

> **Important:** Automation files store API tokens in plain text. Committing `Automations/` to a shared or public repository publishes those tokens. Exclude the folder, or strip the headers before committing.

### Using it across machines

Clone the repository into `~/Documents/Triplo AI/` on each machine, pull, and Triplo picks the files up live. This gives every machine an *editable* copy, unlike [Shares](https://triplo.ai/docs/sync#shares), which arrive read-only.

Don't run both at once for the same items — you will end up with two copies of everything, one editable and one not.

## Power workflows

Four setups that chain several features together.

### The house-style rewriter

**Combines:** Mind + Instruction + Magnets + hotkey.

1. Build a Mind from approved copy — past campaigns, the style guide, phrasing legal has signed off.
2. Write an Instruction stating your tone rules and, importantly, what to avoid.
3. Create a SmartPrompt: *"Rewrite the following in our house style, drawing on approved examples. Return only the rewritten text."*
4. Pin the Mind, the Instruction and a strong model as Magnets.
5. Assign a hotkey.

Anyone with that prompt now writes in your voice, from any application, in one keystroke.

### Meeting notes to tracked tasks

**Combines:** Automation + Magnets + hotkey.

1. Create an automation against your tracker's API, with parameters for title, body and priority.
2. Create a SmartPrompt: *"Extract the single most important action item from these notes."*
3. Pin the automation and a model that reliably emits JSON.
4. Assign a hotkey.

Select a line from your notes, press the key, confirm the values, and the task exists.

### The research desk

**Combines:** a Mind + URL import + the INGEST folder.

1. Create a Mind for the topic.
2. Collect sources as you go: paste URLs in bulk into the Mind editor, or drop PDFs into `INGEST/`.
3. Select the Mind and ask questions of the whole corpus.
4. Use the sources chip on each answer to check where a claim came from, and click through to the original.

*Animation: The percentages are the Mind's own relevance scores — and the list is where the animation stops: in the app, clicking a note opens the original it came from.*

### The confidential setup

**Combines:** local model + local search + Magnets.

1. Add Ollama as a Connection.
2. Build the Mind while online so enrichment can run, then work offline afterwards.
3. Pin the local model to the prompts that touch sensitive material.
4. Do not attach images or audio to those prompts — media processing uses a remote endpoint.

Prompts, retrieved passages and answers all stay on the machine. See [Local-only setup](https://triplo.ai/docs/privacy#local-only).

## Custom and agent endpoints

Anything that speaks the OpenAI chat format can be a Connection, which includes more than model providers.

- **Gateways and proxies**: Point Triplo at your organisation's LLM gateway for central logging, quotas and key management. Triplo never needs the upstream key.
- **Routing layers**: Self-hosted routers that pick a model per request work transparently — Triplo sends the model name you selected and takes what comes back.
- **Agent frameworks**: An agent exposing an OpenAI-compatible server becomes a "model" in Triplo, with its tools and memory behind it. This is how you reach an agent you run yourself; Triplo's own agent, [Pi](https://triplo.ai/docs/agents#pi), needs no endpoint and is always in the droplist. Use [raw pass-through](https://triplo.ai/docs/prompting#raw-passthrough) to send commands verbatim; when such a connection is active, typing `//` also suggests that agent's commands.

Two requirements: `GET /v1/models` must list something, and `POST /v1/chat/completions` must accept the standard body. Streaming is optional — Triplo detects its absence and falls back.