# How to save Quake AI knowledge to Obsidian, Git, or Notion

Source: https://docs.quake.ai/resources/ai-assisted-development/save-to-obsidian-git-notion
Markdown: https://docs.quake.ai/resources/ai-assisted-development/save-to-obsidian-git-notion.md
> Save Quake AI MCP results into your notebook or repository. Every tool response carries a portable Markdown artifact with a suggested vault path, and the export_okf tool returns a linked knowledge bundle you can drop into a vault.

---

# How to save Quake AI knowledge to Obsidian, Git, or Notion

Every Quake AI MCP tool returns a portable Markdown artifact alongside its data. A connected assistant can file that artifact straight into your Obsidian vault, a Git repository, or Notion, so the documentation, templates, and launch handoffs you pull during a session stay in your own notes.

This page covers the save workflow for each destination, the `export_okf` tool for saving a whole linked knowledge bundle, and the fallback for tools without MCP support.

<PrerequisiteBlock methods={["console"]}>

- An AI assistant connected to the Quake AI MCP server. See [How to connect AI tools to Quake AI docs](/resources/ai-assisted-development/ai-assisted-development).
- A notebook or repository to save into: an Obsidian vault, a Git repo, or a Notion workspace.

</PrerequisiteBlock>

## What a saved note contains

Every MCP tool wraps its result in a `PortableArtifact` envelope. The `export` and `metadata` fields give a downstream tool everything it needs to file the result without re-annotation.

| Field | What it holds | How a notebook uses it |
|---|---|---|
| `export.markdown_preview` | Rendered Markdown: YAML frontmatter plus the body | The note content. Obsidian parses the frontmatter as Properties. |
| `export.obsidian_path_suggestion` | A vault-relative path, for example `quake-ai/docs/network/concepts/floating-ips.md` | The folder and filename to save under |
| `export.available_formats` | The formats the artifact renders as: `markdown`, `json`, `hcl`, `yaml` | Lets you save HCL for a template or JSON for a data payload |
| `metadata.quake_ai_docs_url` | The canonical docs URL for the source page | A backlink from the note to the live page |
| `metadata.tags` | Tags for the artifact | Tag the note for later filtering |
| `metadata.generated_at` | ISO 8601 timestamp | Records when you pulled the artifact |

The suggested path is always rooted at `quake-ai/`, so the saved tree drops under an existing notes structure without colliding with your own folders.

| Artifact | Suggested path |
|---|---|
| Documentation page (`search_docs`) | `quake-ai/docs/{slug}.md` |
| IaC template (`get_template`) | `quake-ai/templates/{service}/{template-id}.md` |
| Launch handoff (`prepare_launch`) | `quake-ai/launch/handoffs/{name}-{request-id}.md` |

## Save a single result to Obsidian

Obsidian stores notes as Markdown files with YAML frontmatter, which matches the artifact shape directly. With a connected assistant:

1. Ask the assistant to retrieve what you need, for example *"Search the Quake AI docs for floating IP setup."* The `search_docs` tool returns a `doc_reference` artifact.
2. Ask the assistant to save the result to your vault at the suggested path: *"Save that to my Obsidian vault using the suggested path."*
3. The assistant writes `export.markdown_preview` to a file at `export.obsidian_path_suggestion` inside your vault root.

The saved note opens in Obsidian with its frontmatter rendered as Properties and its cross-links resolved as wikilinks. `search_docs` wires prerequisites and related operations as `[[wikilinks]]` in the preview, so the note links to the neighbouring concepts once you save those too.

To make this repeatable, add a rule to your assistant so it always files Quake AI artifacts at the suggested path. In Cursor, add it to a project rule; in Claude Code, add it to `AGENTS.md`:

```text
When a Quake AI MCP tool returns a PortableArtifact, save export.markdown_preview
to the path in export.obsidian_path_suggestion under my vault root.
```

## Save to a Git repository or Notion

The same artifact files into a repository or a Notion workspace.

**Git or repo docs.** Save `export.markdown_preview` into your `docs/` or `adr/` directory. The frontmatter and the `metadata.quake_ai_docs_url` backlink travel with the file, so a teammate reading the committed note can open the live page. Architecture decisions and template references fit a versioned repo well, since the note changes alongside the code it documents.

**Notion.** Paste the Markdown into a Notion page, or route it through a Notion MCP server so your assistant creates the page directly. Notion imports the Markdown body and the frontmatter values; use `metadata.tags` to tag the page and `metadata.quake_ai_docs_url` for the source link.

## Save a whole knowledge bundle with export_okf

The `export_okf` tool returns a linked knowledge bundle in the [Open Knowledge Format](https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing) for a service or concept, rather than a single page. The bundle is a set of Markdown concept files plus an `index.md`, with cross-links intact. An OKF bundle has the same structure as an Obsidian vault: a directory of Markdown files with YAML frontmatter and Markdown links.

1. Ask the assistant for a bundle, for example *"Export the Quake AI compute knowledge bundle as OKF."*
2. The tool returns the sub-bundle: the concept files, their `index.md`, and the cross-links between them.
3. Save the bundle into your vault or repository. The assistant writes each concept file at its bundle path and keeps the links resolvable.

Each concept file carries a non-empty `type` in its frontmatter and a `resource` pointer to the canonical docs URL, so a saved bundle is a self-describing knowledge subtree you can browse in Obsidian's graph view or commit to a repo.



`export_okf` returns documentation and knowledge-graph concepts only. Operational artifacts such as launch handoff packets stay with the tool that produced them and do not flow into the knowledge bundle.



## When your tool does not support MCP

If your assistant cannot call MCP tools, the documentation is available as plain text and JSON. Save these directly or load them as context.

- Fetch a single page as Markdown by appending `.md` to its docs URL, for example `https://docs.quake.ai/docs/network/concepts/floating-ips.md`.
- Use the corpus and machine-readable surfaces listed on [How to connect AI tools to Quake AI docs](/resources/ai-assisted-development/ai-assisted-development#urls-for-ai-tools-without-mcp-support) for the full set of plain-text and JSON URLs.

## Related

- [How to connect AI tools to Quake AI docs](/resources/ai-assisted-development/ai-assisted-development): set up the MCP server in Cursor, Claude, VS Code, Continue, and Zed.
- [AI tools reference](/resources/ai-assisted-development/ai-tools-reference): the response envelope, export fields, and the `knowledge-graph.json` schema in detail.
- [What the MCP server is and why to use it](/resources/ai-assisted-development/what-is-the-mcp-server): what the server returns and when to reach for each tool.
