Coding agents write Databricks code from training data that's months old. Our Field Guide's MCP server gives Claude Code, Codex, Cursor, VS Code or any MCP client the section that answers the question, with code that runs. The second server, techfabric.com, is where our engineers write from the agent they already use. Both are free.
Connect your agent
Both are remote Streamable HTTP servers: nothing to install, and reading needs no sign-in.
1 · Pick a server
Databricks Field Guide
Databricks answers with working code from our Field Guide, and the docs.databricks.com pages each section cites.
techfabric.com offers a sign-in for its author tools, so Codex may start one for techfabric when you add it. Skip it: every read tool works without signing in. To edit the file by hand, add this.
Add this to .vscode/mcp.json in the workspace, then start the servers from that file or from the MCP view. The tools are there in Copilot's agent mode.
Keep --transport http, because without it Gemini CLI treats the URL as a local command. --scope user writes to ~/.gemini/settings.json for every project; leave it off to write to the project's .gemini/settings.json.
gemini mcp add --transport http --scope user techfabric https://www.techfabric.com/mcp
gemini mcp add --transport http --scope user databricks-field-guide https://databricks.techfabric.com/mcp
If gemini mcp list shows them as disabled, trust the folder. By hand, the settings file takes this.
Point the client at the URL with the Streamable HTTP transport and no authentication. A client that only speaks stdio can reach either server through the mcp-remote bridge, with this as its command.
Set up your AI harness to write for techfabric.com
Pick the agent you already use and follow its steps, from adding the server to publishing your first post. You need a techfabric.com Microsoft account that is on the blog's author list; reading needs neither.
Set up Claude Code
Recommended
One install adds the server, the seven commands and the techfabric-blog skill, and asks you before every publish.
1
Add the server with the plugin
Run this in any terminal. It adds TechFabric's plugin marketplace from GitHub (Fabric-Pro/techfabric-claude-plugin) and installs the plugin, which carries the server's address, so there is nothing else to add. Inside a Claude Code session, /plugin marketplace add Fabric-Pro/techfabric-claude-plugin and then /plugin install techfabric@techfabric do the same, and /reload-plugins turns the plugin on.
Without access to GitHub, the second line installs the same plugin from techfabric.com.
claude plugin marketplace add Fabric-Pro/techfabric-claude-plugin && claude plugin install techfabric@techfabric
claude plugin marketplace add https://www.techfabric.com/mcp-servers/harness/claude-code/marketplace.json && claude plugin install techfabric@techfabric
2
Sign in with Microsoft
Start claude, type /mcp, pick the techfabric server and choose Authenticate. A browser opens on a techfabric.com page that names the app asking and where its access goes. Choose Continue with Microsoft and sign in with your @techfabric.com account, which has to be on the blog's author list. You stay signed in for up to 30 days.
3
Find the commands
Type /techfabric: to see them: write-post, write-case-study, check, preview, publish, revise and status. Whatever you type after a command is passed to it.
4
Try a first prompt
From the repository you want to write about, run the command with your topic, or ask in your own words.
/techfabric:write-post how we cut our Lakeflow job's cold start
Write a TechFabric blog post about how we <the problem you solved or the thing you built>. Ask me for anything you don't know instead of inventing it, and give me the preview link when it's filed.
5
Open the preview
Claude Code is a terminal, so it shows the link rather than the page. Every answer about a draft starts with a line Preview: and the link. Open it to read the post as techfabric.com will publish it, with its cover and diagrams. To edit in the browser instead, use the editor link in the email the site sends you.
6
Publish once you've read it
Run /techfabric:publish with the draft's id. Your agent verifies the saved text with check_draft first, which takes five to ten minutes, and tells you anything still failing. You're then asked to confirm, by the post's name, before anything goes live. Once you say yes, the post is merged and deployed, and your agent can give you the live link. The plugin also asks you to allow every publish_draft call, even in auto mode.
7
If something goes wrong
The tools are missing or failing: type /mcp, pick techfabric and reconnect.
Signed out, or every write asks you to sign in again: your 30 days are up, or your account changed. In /mcp, pick techfabric and choose Re-authenticate, or Clear authentication and sign in again.
A command is missing: run claude plugin marketplace update techfabric, then claude plugin update techfabric@techfabric, and restart Claude Code.
The sign-in page says your address isn't on the author list: ask Preetham Reddy to add you.
Set up Claude Desktop and claude.ai
A custom connector, added once, is there in claude.ai and Claude Desktop alike.
1
Add the server as a custom connector
Open Customize, then Connectors, choose Add and then Add custom connector. Name it techfabric, paste the URL (www.techfabric.com/mcp and techfabric.com/mcp both work), keep the authentication settings Claude detects, and choose Add. On a Team or Enterprise plan, an owner adds it for everyone first, under Organization settings and Connectors, and you find it under Customize and Connectors, marked Custom.
https://www.techfabric.com/mcp
2
Sign in with Microsoft
Choose Connect beside the connector. A browser opens on a techfabric.com page that names the app asking and where its access goes. Choose Continue with Microsoft and sign in with your @techfabric.com account, which has to be on the blog's author list. You stay signed in for up to 30 days.
3
Turn it on in a chat
Nothing to install. In a chat, open the + menu, then Connectors, and make sure techfabric is turned on for that conversation.
4
Try a first prompt
Paste this, with your own topic, and attach the notes or code it should draw on.
Write a TechFabric blog post about how we <the problem you solved or the thing you built>. Ask me for anything you don't know instead of inventing it, and give me the preview link when it's filed.
5
Open the preview
Claude renders MCP Apps, so a draft the server sends as an app opens in the conversation with its checks beside it. Every answer about a draft also starts with a line Preview: and the link, which opens the post as techfabric.com will publish it.
6
Publish once you've read it
Ask Claude to publish the draft. Your agent verifies the saved text with check_draft first, which takes five to ten minutes, and tells you anything still failing. You're then asked to confirm, by the post's name, before anything goes live. Once you say yes, the post is merged and deployed, and your agent can give you the live link.
7
If something goes wrong
The tools are missing: check the connector is turned on in the chat's + menu, or open Customize, Connectors and connect it again.
Signed out, or every write asks you to sign in again: your 30 days are up, or your account changed. Choose Connect on the connector again. Its sign-in settings can't be edited, so to change them, remove the connector and add it again.
The sign-in page says your address isn't on the author list: ask Preetham Reddy to add you.
Set up ChatGPT
A custom MCP server, added as a plugin on chatgpt.com.
1
Add the server as a plugin
Go to chatgpt.com/plugins, choose + and then Add custom MCP server. Name it techfabric, paste the URL under Connection, choose OAuth for authentication, then I understand and want to continue and Create as a plugin, and install it. If Add custom MCP server isn't there, ask your workspace's admin.
https://www.techfabric.com/mcp
2
Sign in with Microsoft
ChatGPT starts the sign-in when you connect the plugin. A browser opens on a techfabric.com page that names the app asking and where its access goes. Choose Continue with Microsoft and sign in with your @techfabric.com account, which has to be on the blog's author list. You stay signed in for up to 30 days.
3
Add it to a chat
Nothing to install, and ChatGPT has no slash commands for the server. In a new chat, type @ and pick techfabric.
4
Try a first prompt
Paste this, with your own topic and the notes it should draw on.
Write a TechFabric blog post about how we <the problem you solved or the thing you built>. Ask me for anything you don't know instead of inventing it, and give me the preview link when it's filed.
5
Open the preview
ChatGPT renders MCP Apps, so a draft the server sends as an app opens in the conversation with its checks beside it. Every answer about a draft also starts with a line Preview: and the link, which opens the post as techfabric.com will publish it.
6
Publish once you've read it
Ask ChatGPT to publish the draft. Your agent verifies the saved text with check_draft first, which takes five to ten minutes, and tells you anything still failing. You're then asked to confirm, by the post's name, before anything goes live. Once you say yes, the post is merged and deployed, and your agent can give you the live link.
7
If something goes wrong
The tools are missing: start a new chat and pick techfabric with @ again. If a tool still isn't there, choose Refresh on it at chatgpt.com/plugins.
Signed out, or every write asks you to sign in again: your 30 days are up, or your account changed. Connect the plugin again at chatgpt.com/plugins.
The sign-in page says your address isn't on the author list: ask Preetham Reddy to add you.
Set up Codex
The CLI, and the IDE extension that reads the same config. The commands come as skills you call by name.
1
Add the server
Run this in any terminal. Codex writes it to ~/.codex/config.toml, which the IDE extension reads too.
Run codex mcp login techfabric. A browser opens on a techfabric.com page that names the app asking and where its access goes. Choose Continue with Microsoft and sign in with your @techfabric.com account, which has to be on the blog's author list. You stay signed in for up to 30 days.
codex mcp login techfabric
3
Install the commands
This adds one skill per command in ~/.agents/skills. Codex runs one only when you name it: type $techfabric-write-post, or /skills to see them all.
curl -fsSL https://www.techfabric.com/mcp-servers/harness/install.sh | sh -s -- codex
4
Try a first prompt
From the repository you want to write about, start codex and run the skill with your topic, or ask in your own words.
$techfabric-write-post how we cut our Lakeflow job's cold start
Write a TechFabric blog post about how we <the problem you solved or the thing you built>. Ask me for anything you don't know instead of inventing it, and give me the preview link when it's filed.
5
Open the preview
The Codex CLI doesn't show MCP Apps yet. Every answer about a draft starts with a line Preview: and the link. Open it to read the post as techfabric.com will publish it, with its cover and diagrams. To edit in the browser instead, use the editor link in the email the site sends you.
6
Publish once you've read it
Type $techfabric-publish with the draft's id. Your agent verifies the saved text with check_draft first, which takes five to ten minutes, and tells you anything still failing. You're then asked to confirm, by the post's name, before anything goes live. Once you say yes, the post is merged and deployed, and your agent can give you the live link.
7
If something goes wrong
The tools are missing: run codex mcp list to see that techfabric is there and enabled, or /mcp inside Codex, then restart Codex.
Signed out, or every write asks you to sign in again: your 30 days are up, or your account changed. Run codex mcp login techfabric again.
A skill is missing: run the install line again and restart Codex.
The sign-in page says your address isn't on the author list: ask Preetham Reddy to add you.
Set up Cursor
The server in Cursor's MCP settings, and the commands as skills in the project you write from.
1
Add the server
Add this to ~/.cursor/mcp.json for every project, or to .cursor/mcp.json in one. Cursor lists the server with its other MCP servers, on its Customize page.
Find techfabric with Cursor's other MCP servers and sign in from there, or call one of its write tools and Cursor asks. A browser opens on a techfabric.com page that names the app asking and where its access goes. Choose Continue with Microsoft and sign in with your @techfabric.com account, which has to be on the blog's author list. You stay signed in for up to 30 days.
3
Install the commands
Run this in the project you write from. It adds the commands as skills in .cursor/skills, which run only when you type them, and a rule in .cursor/rules that points the agent at the server.
curl -fsSL https://www.techfabric.com/mcp-servers/harness/install.sh | sh -s -- cursor
4
Try a first prompt
In the agent, type the command with your topic, or ask in your own words.
/techfabric-write-post how we cut our Lakeflow job's cold start
Write a TechFabric blog post about how we <the problem you solved or the thing you built>. Ask me for anything you don't know instead of inventing it, and give me the preview link when it's filed.
5
Open the preview
Cursor renders MCP Apps, so a draft the server sends as an app opens in the conversation with its checks beside it. Every answer about a draft also starts with a line Preview: and the link, which opens the post as techfabric.com will publish it.
6
Publish once you've read it
Type /techfabric-publish with the draft's id. Your agent verifies the saved text with check_draft first, which takes five to ten minutes, and tells you anything still failing. You're then asked to confirm, by the post's name, before anything goes live. Once you say yes, the post is merged and deployed, and your agent can give you the live link.
7
If something goes wrong
The tools are missing: where Cursor lists its MCP servers, check techfabric is turned on, and turn it off and on again to reconnect.
Signed out, or every write asks you to sign in again: your 30 days are up, or your account changed. Sign in to techfabric again where Cursor lists it.
A command is missing: run the install line again in the project and reload Cursor.
The sign-in page says your address isn't on the author list: ask Preetham Reddy to add you.
Set up VS Code with GitHub Copilot
The server in Copilot's agent mode. Its commands are the server's own prompts, so there's nothing else to install.
1
Add the server
Run MCP: Add Server from the Command Palette, choose HTTP (HTTP or Server-Sent Events), paste the URL, name it techfabric and pick where to save it. Or add this to .vscode/mcp.json in your workspace.
Start the server from mcp.json or the MCP view. VS Code asks whether techfabric may sign in; allow it. A browser opens on a techfabric.com page that names the app asking and where its access goes. Choose Continue with Microsoft and sign in with your @techfabric.com account, which has to be on the blog's author list. You stay signed in for up to 30 days.
3
Find the commands
Nothing to install. In Copilot Chat, in agent mode, type /techfabric. to see the commands. VS Code asks for each argument.
4
Try a first prompt
Run the command and give it your topic, or ask in your own words.
/techfabric.write-post
Write a TechFabric blog post about how we <the problem you solved or the thing you built>. Ask me for anything you don't know instead of inventing it, and give me the preview link when it's filed.
5
Open the preview
VS Code renders MCP Apps in chat when the experimental chat.mcp.apps.enabled setting is on, so a draft the server sends as an app opens in the conversation with its checks beside it. Every answer about a draft also starts with a line Preview: and the link, which opens the post as techfabric.com will publish it.
6
Publish once you've read it
Run /techfabric.publish with the draft's id. Your agent verifies the saved text with check_draft first, which takes five to ten minutes, and tells you anything still failing. You're then asked to confirm, by the post's name, before anything goes live. Once you say yes, the post is merged and deployed, and your agent can give you the live link.
7
If something goes wrong
The tools are missing: run MCP: List Servers, pick techfabric and restart it.
Signed out, or every write asks you to sign in again: your 30 days are up, or your account changed. Restart the server and allow the sign-in again. Manage Trusted MCP Servers, in the Accounts menu, shows which servers may use your sign-in.
The sign-in page says your address isn't on the author list: ask Preetham Reddy to add you.
Set up Gemini CLI
The server for every project. Its commands are the server's own prompts, as slash commands.
1
Add the server
Run this in any terminal. Keep --transport http: without it Gemini CLI treats the URL as a local command.
gemini mcp add --transport http --scope user techfabric https://www.techfabric.com/mcp
2
Sign in with Microsoft
Start gemini and type /mcp auth techfabric. A browser opens on a techfabric.com page that names the app asking and where its access goes. Choose Continue with Microsoft and sign in with your @techfabric.com account, which has to be on the blog's author list. You stay signed in for up to 30 days.
/mcp auth techfabric
3
Find the commands
Nothing to install. Type /write-post, /publish and the rest, with arguments by name, such as --topic and --id.
4
Try a first prompt
From the repository you want to write about, run the command with your topic, or ask in your own words.
/write-post --topic="how we cut our Lakeflow job's cold start"
Write a TechFabric blog post about how we <the problem you solved or the thing you built>. Ask me for anything you don't know instead of inventing it, and give me the preview link when it's filed.
5
Open the preview
Gemini CLI is a terminal, so it shows the link rather than the page. Every answer about a draft starts with a line Preview: and the link. Open it to read the post as techfabric.com will publish it, with its cover and diagrams. To edit in the browser instead, use the editor link in the email the site sends you.
6
Publish once you've read it
Run /publish --id=<the draft's id>. Your agent verifies the saved text with check_draft first, which takes five to ten minutes, and tells you anything still failing. You're then asked to confirm, by the post's name, before anything goes live. Once you say yes, the post is merged and deployed, and your agent can give you the live link.
7
If something goes wrong
The tools are missing: type /mcp list. If techfabric shows as disabled, run /mcp enable techfabric. If Gemini CLI says the folder isn't trusted, trust the folder you started it in, because it runs no MCP server in an untrusted one.
Signed out, or every write asks you to sign in again: your 30 days are up, or your account changed. Type /mcp auth techfabric again.
The sign-in page says your address isn't on the author list: ask Preetham Reddy to add you.
Set up Fabric Agents
You paste a line for each step and your Fabric agent sets it up with fabric-cli.
1
Add the server as a source
Paste this into a Fabric Agents session. The agent adds techfabric.com's MCP server as a source named TechFabric, with OAuth sign-in. For a draft every weekday as well, paste the Fabric Agents line under daily drafts on this page instead.
Add techfabric.com's MCP server to this workspace as a source: follow step 1 only of https://www.techfabric.com/mcp-servers/daily-drafts/fabric-agents.md
2
Sign in with Microsoft
When the agent asks, authenticate the TechFabric source. A browser opens on a techfabric.com page that names the app asking and where its access goes. Choose Continue with Microsoft and sign in with your @techfabric.com account, which has to be on the blog's author list. You stay signed in for up to 30 days.
3
Install the commands
Paste this too. The agent adds a skill per command, each needing the TechFabric source.
Add the TechFabric commands to this workspace: follow https://www.techfabric.com/mcp-servers/harness/fabric/README.md
4
Try a first prompt
Type the command with your topic, or ask in your own words.
@techfabric-write-post how we cut our Lakeflow job's cold start
Write a TechFabric blog post about how we <the problem you solved or the thing you built>. Ask me for anything you don't know instead of inventing it, and give me the preview link when it's filed.
5
Open the preview
Fabric Agents doesn't show MCP Apps. Every answer about a draft starts with a line Preview: and the link. Open it to read the post as techfabric.com will publish it, with its cover and diagrams. To edit in the browser instead, use the editor link in the email the site sends you.
6
Publish once you've read it
Type @techfabric-publish with the draft's id. Your agent verifies the saved text with check_draft first, which takes five to ten minutes, and tells you anything still failing. You're then asked to confirm, by the post's name, before anything goes live. Once you say yes, the post is merged and deployed, and your agent can give you the live link. None of the commands publishes from an automation.
7
If something goes wrong
The tools are missing: ask the agent to run fabric-cli source validate techfabric and authenticate the source again if it fails.
Signed out, or every write asks you to sign in again: your 30 days are up, or your account changed. Authenticate the TechFabric source again.
A command is missing: paste the commands line from step 3 again.
The sign-in page says your address isn't on the author list: ask Preetham Reddy to add you.
The servers
What does each of TechFabric's MCP servers do?
The Field Guide answers Databricks questions with code; it has five read-only tools. techfabric.com has nine: five for our authors, who check and file drafts from their own agent, and four anyone can use to search and read the site.
Databricks Field Guide MCP server
The Databricks Field Guide is what our engineers know about building, running and paying for Databricks. Ask how to add a Unity Catalog row filter, and the agent gets the section that explains it, the SQL function from that section, and the docs.databricks.com pages the section cites. Databricks' documentation stays the authority on syntax and limits.
5 tools
search_guideSearch the guide
get_chapterRead a chapter
get_code_examplesFind code examples
whats_newWhat's new in Databricks
list_chaptersList chapters
Sign-in
None. The server is public and read-only, and it has no write tools.
Rate limits
60 calls a minute and 300 an hour per IP address.
Freshness
Rebuilt on every deploy of the guide. Every answer carries the commit that built it, each page's last-changed date and how long it may be cached, which is 10 minutes for what's new, 15 for search and an hour for chapters and code.
Protocol
MCP revision 2026-07-28 over Streamable HTTP. Clients still on 2025-11-25 are served on the same URL.
The guide sections that answer a Databricks question.
Returns and parameters +
Returns
The chapter sections, margin notes and events that answer a Databricks question, best first, each with a snippet, its URL with the section anchor, and when the page last changed.
Parameters
query (required); kind: chapter, note, feature or event; limit 1 to 25, default 10
get_chapterRead
Read a chapter
A chapter or one section as Markdown, code intact.
Returns and parameters +
Returns
A chapter or margin note as clean Markdown with its code intact, or one section of it, plus the outline, the code blocks listed separately, the FAQs, the dates and the docs.databricks.com links it cites.
Parameters
slug (required): a slug such as lakebase, a path or any guide URL; section: an anchor or a heading
get_code_examplesRead
Find code examples
SQL, Python, CLI and config blocks for a topic.
Returns and parameters +
Returns
SQL, Python, CLI and config blocks that match a topic, each with the explanation around it, the section it came from and the docs links that section cites.
Parameters
topic (required); lang such as sql, python, bash, yaml, json or hcl; limit 1 to 25, default 8
whats_newRead
What's new in Databricks
Recent Databricks changes the guide tracks, newest first.
Returns and parameters +
Returns
Recent Databricks changes the guide tracks, newest first: margin notes, release-stage changes with links to Databricks' documentation and release notes, and chapters updated.
Parameters
since (YYYY-MM-DD, default the last 30 days); limit 1 to 200, default 30
list_chaptersRead
List chapters
The table of contents, with each chapter's main sections.
Returns and parameters +
Returns
Every chapter in the guide's order, with its part, summary, dates, URL, Markdown URL and main sections, and the margin notes.
Parameters
None
fieldguide://llms.txt
Every chapter, note and feature page, one line each.
fieldguide://page/{+path}
Any published page as Markdown, for example fieldguide://page/guide/lakebase.
techfabric.com MCP server
Its main use is writing: an engineer's agent drafts a post from the repository and context it already has, runs the site's checks and files it, and once the engineer has read the preview and confirmed, publishes it. The workflow is under writing a post with your own agent.
Its read tools answer only from published, indexable pages, so drafts, previews and anything marked noindex never appear in a result.
12 tools
searchSearch techfabric.com
get_pageRead a page
list_postsList blog posts
get_servicesWhat TechFabric offers
get_briefToday's briefAuthor
lint_draftLint a draftAuthor
check_draftCheck a draftAuthor
submit_draftSubmit a draftAuthor
get_statusWhere a draft standsAuthor
update_draftSave an edit to your draftAuthor
publish_draftPublish your draftAuthor
revise_postChange a published postAuthor
Sign-in
None to read. The write tools are for TechFabric blog authors, who sign in with their Microsoft (Office 365) account in the techfabric.com tenant. No other tenant is accepted.
Rate limits
300 anonymous calls per IP address per hour. Signed-in calls are counted per author, at 600 an hour, with at most 20 new check runs, 6 submissions and 30 saves.
Freshness
The index is rebuilt from the site on every deploy. Resources may be cached for an hour, and search results for 15 minutes.
Protocol
MCP revision 2026-07-28 over Streamable HTTP. Clients still on 2025-11-25 are served on the same URL.
Blog posts, service and solution pages, case studies, city pages and events that match, best first, each with its title, URL, summary, date, author and type.
Parameters
query (required); type: post, service, solution, case_study, city, event or page; limit 1 to 25, default 10
get_pageRead
Read a page
One published page as clean Markdown, with its FAQs.
Returns and parameters +
Returns
One published page as clean Markdown, with its title, search title, description, dates, author, tags, its FAQs as question and answer pairs, and its canonical URL.
Parameters
url_or_slug (required): a full URL, a path such as /services/databricks, or a post's slug
list_postsRead
List blog posts
Blog posts, newest first, by tag, author or date.
Returns and parameters +
Returns
Blog posts, newest first.
Parameters
tag, author (a name or a slug), since (YYYY-MM-DD); limit 1 to 100, default 20
get_servicesRead
What TechFabric offers
Every service and product page, with its own summary.
Returns and parameters +
Returns
Every service, solution, Databricks, AI, cloud, software, accelerator and product page, with its name, URL, kind and summary exactly as the live page states them.
Parameters
None
get_briefAuthor
Today's brief
Today's topic for a daily draft, held for you for a day.
Returns and parameters +
Returns
Today's topic for a daily draft, held for the signed-in author for 24 hours: the angle, the search to answer, sources, pages to link and the brief's id. If today's post has gone to a colleague, the site's pace is used up or nothing fits your work, it says why instead.
Parameters
None
lint_draftAuthor
Lint a draft
The site's rule-based checks, in about a second.
Returns and parameters +
Returns
Runs the site's rule-based checks on a post, with no model, and returns each item's status and findings, with the passage each finding is about and what to do. Also returns judge_rubric: the reader, the questions and the thresholds the judged checks use. Files nothing.
Parameters
markdown (required, with frontmatter); images (names); kind; sources; slug
check_draftAuthor
Check a draft
The full checks, our judge included, once per final text.
Returns and parameters +
Returns
Runs the editor's full Run checks, judged checks included, and returns each item's status and findings. With a draft's id it checks the saved text, which publish_draft needs. A full run takes five to ten minutes.
Parameters
id (a saved draft) or markdown (with frontmatter); images; wait_seconds up to 50, default 25
submit_draftAuthor
Submit a draft
A draft filed under your byline, with its preview.
Returns and parameters +
Returns
Files the post under the signed-in author's byline exactly as written, builds a preview and emails the author the editor link. Returns the draft's id.
Parameters
title and markdown (required); images
get_statusAuthor
Where a draft stands
A draft's state, failing checks, base_sha and links.
Returns and parameters +
Returns
One of your own drafts: its state, what's failing, the last check run, its current Markdown, the preview link and, once it's published, the live link. The editor link is only in your email.
Parameters
id (required)
update_draftAuthor
Save an edit to your draft
A new saved version of your draft; the preview rebuilds.
Returns and parameters +
Returns
Saves a new version of your own draft in a second or two and returns its text_hash, your next base_hash. The commit and the preview follow in the background. It runs no checks, so lint the text first; check_draft with the id can run on the saved text straight away. A second save within a minute may be asked to retry while the first is committed.
Parameters
id, markdown and base_hash (base_hash comes from get_status, or from your last save; base_sha also works)
publish_draftAuthor
Publish your draft
Your draft live on techfabric.com, once you confirm.
Returns and parameters +
Returns
Publishes your own draft through the editor's own Publish, once check_draft with its id has passed on the saved text. The first call publishes nothing: you're asked to confirm, in your client or by your agent with a one-time confirmation. Then the site merges and deploys it.
Parameters
id (required); confirmation (only on the second call); override (the failing wording checks to publish past); confirm_via
revise_postAuthor
Change a published post
A revision of a live post, as a draft with its preview.
Returns and parameters +
Returns
Opens a revision of a post that's already live, for its author or the blog's editor: a draft that starts as the live text, with its own preview. The same tools edit, check and publish it, and publishing replaces the live post at the same URL under the same byline.
Parameters
post (required: the post's URL or slug)
site://llms.txt
The site's map for language models.
site://page/{+path}
Any published page as Markdown, for example site://page/services/databricks.
site://search?query=
The search tool's results as a resource a client can cache, with an optional type.
techfabric://editorial/rules
The house writing rules an author's agent reads before it drafts.
Try it
What can you ask TechFabric's MCP servers?
For techfabric.com, mostly writing; for the Field Guide, anything it covers. Name the server the first time, so the agent knows which tools to reach for; after that it usually picks them on its own.
Prompts for the techfabric.com server
"Using the techfabric server, get today's brief and draft the post from what we built in this repo, leaving out anything that belongs to a client."
"Turn what we built in this repo into a case study draft for techfabric.com. Read the techfabric editorial_rules resource first, tell me whether its client register lets us name the client, and ask me for the outcome numbers. Run lint_draft with kind "case-study" and fix what it finds until it passes, then submit it with submit_draft and give me the preview link."
"Submit this draft to techfabric.com with submit_draft and give me the preview link."
"Verify my techfabric.com draft with check_draft and its id, and if it passes, publish it with publish_draft once I say yes."
"Search techfabric.com for what we've already written about Lakebase, so the new post doesn't repeat it."
Prompts for the Databricks Field Guide server
"Ask the Databricks Field Guide how to give each pull request its own Lakebase branch, and show me the CLI command it uses."
"What has Databricks changed in the last two weeks, according to the Field Guide?"
"Find SQL examples of Unity Catalog row filters in the Field Guide, then check the docs.databricks.com links they cite for the current syntax."
"List the Field Guide's chapters, then read me the Lakebase chapter's section on why a branch costs almost nothing."
How it works
How does an AI agent use an MCP server?
The Model Context Protocol (MCP) is the open standard AI assistants use to call tools on other systems. An agent connected to an MCP server can look something up halfway through a task and get a structured answer back, with a URL to cite, where it would otherwise guess from its training data or scrape a web page.
One agent, two servers. Reading either one needs no sign-in; only the techfabric.com write tools ask a TechFabric author to sign in with Microsoft, and nothing on either server publishes.
For TechFabric authors
How to write a TechFabric blog post with your own agent
Your agent writes the post from what you actually did, checks it as it goes, and publishes it once you've read the preview and said yes. Writing needs a techfabric.com Microsoft account that is on the blog's author list.
1 · Set up the server
Any MCP client that supports sign-in works: Claude Code, Claude Desktop and claude.ai, Codex, Cursor, VS Code, or your own agent. In Claude Code, add the server once, for all your projects.
claude mcp add --transport http --scope user techfabric https://www.techfabric.com/mcp
Then run /mcp, pick techfabric and choose Authenticate. If you skip that, Claude Code asks you to sign in the first time your agent calls a write tool. In Claude Desktop or claude.ai, add a custom connector named techfabric with the URL above, as in how to connect, and choose Connect. Every other harness, step by step, is in set up your AI harness.
2 · Sign in with Microsoft
Either way a browser opens on a techfabric.com page that names the client asking and where its access goes. Choose Continue with Microsoft and sign in with your @techfabric.com account. Access lasts an hour and renews itself for 30 days.
A prompt to start from
Replace the placeholder with something you built or fixed. The prompt asks the agent to read the rules first.
Read techfabric.com's editorial rules (the techfabric editorial_rules resource), then write a TechFabric blog post about how we <solved this problem or built this thing>. Draft only from what I actually did and what's in this project; never name a client the rules don't approve, and ask me for any fact you don't have instead of inventing it. Run lint_draft and fix every finding until it passes, review the draft against the judge_rubric it returns, then submit it with submit_draft and give me the preview link.
A case study instead of a post
Send kind "case-study" to lint_draft, check_draft, submit_draft and update_draft. The preview is the case study's page at /case-studies/<slug>, and it's verified and published as a post is: check_draft with its id, then publish_draft once you confirm, or from the editor link.
Its frontmatter is title, description, sector, stack (a list) and track (ai, migration or other). Add client when the client register approves naming that client in a case study, or when the client agreed to be named (below). Logo, website and metrics are never yours to set.
Its body opens with four sections, in order: Challenge, Strategy, Solution, Results. Each starts with a bold one-line statement of its argument, then prose. Anything else goes after Results.
Without an approved client, anonymise it by industry and size ("a regional credit union with about 40 branches") and name no client anywhere. To name a client the register doesn't approve, you need the client's confirmation: say you have it with client_confirmed: true, or with "I have the client's confirmation to name ..." on the check's finding in the editor. It's recorded under your name.
Every number is a client fact. Your agent asks you for the outcome numbers and never invents or estimates one, and the check holds each number to the sources sent with the case study: your notes and the project's own records. A source isn't an approval: a client's metric is published only with an approval recorded in the client register, or when lib/work.ts already carries it, and the check can't confirm that, so you do before you publish.
Turn what we built in this repo into a case study draft for techfabric.com. Read the techfabric editorial_rules resource first, tell me whether its client register lets us name the client, and ask me for the outcome numbers. Run lint_draft with kind "case-study" and fix what it finds until it passes, then submit it with submit_draft and give me the preview link.
The workflow, step by step
Step 1
Read the editorial rules
Your agent reads the editorial_rules resource (techfabric://editorial/rules). It starts with client confidentiality, which decides what the post may say, then gives the frontmatter, this workflow and the house writing rules.
Step 2
Draft from your own work
Your agent drafts the post, frontmatter and all, from your own work: the repository you're in and your notes. The frontmatter needs a title and a description at least, or lint_draft, check_draft, submit_draft and update_draft refuse it. What you told your agent about your work, in your words, goes with the post as sources. The fact-check treats them as your own account, so a first-hand sentence they don't back comes back as a finding.
Step 3
Lint it until it passes
Your agent runs lint_draft on the whole post. It runs the site's rule-based checks on the text itself: the slop rules, claims, known errors, the title and description, the opening, the ending, the FAQ, the diagram and the images. No model reads it, so it answers in about a second. Its rewrite_plan lists each passage with what to write instead, and its next_action says the one next step, so the agent rewrites and lints again until it passes.
Step 4
Review it against the judge's rubric
lint_draft also returns judge_rubric: the reader the post is judged as, with what they already know and what they're trying to fix, each question our judge will ask with its threshold, the first screen the buyer test reads, and the sentences the fact-check will want a source for most: our own claims that carry a number. Your agent reads the draft as that reader, answers each question as that reader would, and revises until every answer clears.
Step 5
Submit it under your byline
Your agent calls submit_draft. The post is filed under your own byline exactly as written. The site sets the author, today's date and draft: true, and adds the reading time if it's missing. It renders the diagrams, draws the cover and share image, builds the branded preview and emails it to you. The agent gets the draft's id back, follows it with get_status, and shows you the preview link after every submit and every update.
Step 6
Revise with update_draft
For revisions your agent lints the new text, then calls update_draft with the id, the whole new post and the base_hash from get_status (base_sha also works). A save returns in seconds and runs no checks; the preview rebuilds in the background. update_draft is refused if the draft has changed since that base_hash, or while it's open in the browser editor.
Step 7
Verify the saved text once
Your agent calls check_draft with the draft's id: the editor's full Run checks on exactly the saved text, with our judge, the slop classifier and the blog writer's fact-check, in five to ten minutes. When something fails, its rewrite_plan and next_action say what to rewrite. Your agent rewrites, saves with update_draft, lints and verifies again, for up to 6 rounds. Then it stops and shows you what's left. A re-check of the same text comes from the cache.
Step 8
Publish once you confirm
Your agent calls publish_draft with the id, and the first call publishes nothing. Your client asks you, naming the post, or your agent gets a one-time confirmation and sends it back only after you say yes. If your client shows the draft card, you answer its question once, then your client asks you to allow the publish. The post then goes through the editor's own Publish and deploy; a failure brings the draft back.
What our side does and doesn't do
Your text is the draft. Our blog writer doesn't redraft it, but its fact-checker reads it: check_draft checks every claim against the pages your post links, what you told your agent, your own posts and the approved client facts. Each flagged sentence comes back with what to write instead. An unsourced result, metric or client holds the post for everyone. Your agent can't publish past any fact-check finding, and the claims and known-errors checks always have to pass.
If only wording and style checks fail, you can publish anyway from the editor, and the choice is recorded. publish_draft can name some of those checks too, but never the fact-check, the slop and machine-writing checks or the opening: your agent fixes those until they pass. Checks that keep the page working (build, images, diagrams, links, placeholders) and the rules on claims, our own spend and secrets always have to pass.
Keep your edits in your agent and update_draft unless you want the writer involved. Replying to the preview email is different, because the reply goes to our blog writer. If the writer then needs a fact only you have, get_status asks you for it, or, in a client that supports MCP tasks, the open task does.
Rules to know
No client names, data, metrics, schemas, incidents or code unless the client is approved for publication, and then only as far as the approval goes. The editorial rules list who's approved. A client's name, and only the name, may also go in when the client agreed and you say so (client_confirmed). When in doubt, generalise it or leave it out.
First-hand claims must be true. Write "we" only for what we did, and never let the agent invent a number, a result, a client or a quote.
See it in your harness
In a host that renders MCP Apps, the draft tools open the post in the conversation as techfabric.com will show it, with its cover, diagrams and FAQ.
Beside it are the checks. Each shows its finding, the passage it's about, and whether you may publish past it or it has to pass.
You can run the checks again from there. **Ask the agent to fix this** hands a finding back to your agent, which edits and saves the draft, so writing stays with the agent.
**Publish** works once the checks pass on the saved text, and asks you to confirm first. When only wording checks fail, **Publish anyway** lists them before you confirm. The editor link in your email works too, and the app never shows it.
Hosts that support MCP Apps, per the official MCP client matrix in October 2026: Claude (claude.ai and Claude Desktop), ChatGPT, VS Code with GitHub Copilot, Microsoft 365 Copilot, Cursor, Goose, the Codex desktop app, Postman and MCPJam. In Claude Code, the Codex CLI and Fabric Agents, the answers come back as text, starting with the preview link.
Change a published post
Your agent calls revise_post with the post's URL. Only the post's author (the engineer its byline names) or the blog's editor can open one. It opens a revision whose first draft is the live text, on its own branch with its own preview, and emails you the preview and the editor link. Asking again for the same post returns the revision that's already open.
From there it's a draft like any other. get_status with the revision's id gives the markdown and base_sha, your agent edits and runs lint_draft (with the post's slug) and update_draft, then check_draft with the id verifies the saved text, and publish_draft publishes once you confirm. The editor link from the email works the same way.
Publishing replaces the live post at the same URL. The byline stays, and a save or publish that changes it is refused. A title change keeps the URL; changing a live URL needs a redirect, so ask the blog's editor. The original publish date stays, and the page shows "Updated" with the day. The sitemap's last-modified time moves and the deploy submits the URL to IndexNow, so search engines can see the post changed.
A one-word fix still has to pass the checks that keep the page working and the rules on claims, our own spend and secrets. If only wording and style checks fail, you can publish anyway, as for a new post.
If someone changes the live post while your revision is open, publishing stops instead of overwriting it. The live post's changes come into your draft along with yours, and wherever you both changed the same passage, the live wording stays and yours is listed on the draft. Read it, save, check again, then publish. Discarding a revision, from the link in its email, leaves the live post as it is.
Without an agent, ask for a link at https://www.techfabric.com/api/ideas/revise. If your address may edit the post, it gets an "Edit this post" link that opens the same revision.
Change my published post at <its URL on techfabric.com>: <what to change>. Open it with the techfabric revise_post tool, edit the markdown get_status returns, run lint_draft with the post's slug until it passes, save it with update_draft, verify it with check_draft and the id, then ask me before publish_draft.
Troubleshooting +
Sign-in refused
The sign-in page says why. If it says your address is not on techfabric.com's author list yet, there's no byline to draft under, so ask Preetham Reddy to add you. If it says only TechFabric's Microsoft accounts or only @techfabric.com accounts can sign in, or that guest accounts can't, you signed in with another Microsoft account; sign in again with your own @techfabric.com one. If it says the app can't connect, the client asked to send its sign-in somewhere MCP doesn't allow (plain http to another computer); update the client.
A check keeps failing
Have your agent run lint_draft on the text: each finding names its passage and what to do. A judged check (the reader test, helpful content) that fails in check_draft comes with its scores; have the agent revise against judge_rubric, call update_draft, and verify again. The editor link from your email shows the same checklist.
Too many calls
Signed in, the limits per hour are 600 calls, 240 lints, 20 new check runs, 6 submissions, 6 revisions opened, 30 saves and 10 publishes. Checking text that was already checked doesn't count as a new run.
Anything else
Ask Preetham Reddy, who runs the blog.
For TechFabric authors
Commands for writing and publishing from your agent
You don't have to remember the tool order. The server comes with 7 commands, and each one gives your agent the exact steps and points it at the house rules. Most agents show them as slash commands; for the ones that don't, we ship the same commands in their own format.
write-post
Draft a techfabric.com blog post under your byline, from today's brief or a topic of your own. Your agent asks you for the first-hand detail, checks the draft and files it; you publish it.
write-case-study
Draft a techfabric.com case study about a project you worked on. Your agent asks for the outcome numbers and their sources, and for the client's confirmation before it names a client the register doesn't approve.
check
Run techfabric.com's checks on a draft and explain each finding in plain words, with the fix your agent proposes. Nothing changes until you agree.
preview
Show a draft as techfabric.com will publish it: the preview link, or the draft app in a host that renders MCP Apps.
publish
Publish one of your drafts to techfabric.com. Your agent checks it, tells you what still fails, and publishes only after you say yes.
revise
Apply a reviewer's feedback, or your own change, to one of your drafts or to a post that's already live, check it again and save it, keeping your first-hand facts as they are.
status
List your drafts and where each one stands, or one draft in detail: what's failing, its preview, and what to do next.
New to the server? Set up your AI harness first, from adding the server to signing in. publish always asks you first, and none of them publishes in a scheduled run. You can also attach today's brief (techfabric://brief/today) or one of your drafts (techfabric://drafts/<id>) to a message, in an agent that lets you attach resources.
The commands in your agent
Claude Code
A plugin: the server, the commands and the techfabric-blog skill in one install.
claude plugin marketplace add Fabric-Pro/techfabric-claude-plugin && claude plugin install techfabric@techfabric
Then run /mcp, pick techfabric, choose Authenticate and sign in. Type /techfabric: to see the commands. Everything after a command is passed to it, so /techfabric:write-post how we cut Lakeflow cold starts works as written. Before every publish_draft, the plugin asks you to allow it, even in auto mode. Without the plugin, the server's own prompts show up as /techfabric:write-post (MCP) and so on, but Claude Code splits their arguments at each space.
claude plugin marketplace add https://www.techfabric.com/mcp-servers/harness/claude-code/marketplace.json && claude plugin install techfabric@techfabric
For example
/techfabric:write-post today's brief
Codex
Type $techfabric-write-post and the rest: one skill per command, run only when you name it.
curl -fsSL https://www.techfabric.com/mcp-servers/harness/install.sh | sh -s -- codex
They go in ~/.agents/skills, one skill per command, and Codex runs them only when you name one: type $techfabric-write-post, or /skills to see them all. The server itself is added as in how to connect.
For example
$techfabric-write-post today's brief
Cursor
Skills you run as slash commands, and one rule, in the project you write from.
curl -fsSL https://www.techfabric.com/mcp-servers/harness/install.sh | sh -s -- cursor
Run it in the project you write from. It adds the commands as skills in .cursor/skills, which run only when you type them, and a rule in .cursor/rules that points the agent at the server.
For example
/techfabric-write-post today's brief
VS Code
The server's prompts, in Copilot Chat. Nothing to install beyond the server.
Type /techfabric.write-post in Copilot Chat. VS Code asks for each argument and suggests values, such as your own draft ids once you're signed in.
For example
/techfabric.write-post
Gemini CLI
The server's prompts, as slash commands with named arguments.
Type /write-post --topic="today's brief". The arguments are --topic, --project, --client, --id and --feedback, as each command takes them.
For example
/write-post --topic="today's brief"
Fabric Agents
Type @techfabric-write-post and the rest, in a workspace with techfabric.com's MCP server added as a source.
Add the TechFabric commands to this workspace: follow https://www.techfabric.com/mcp-servers/harness/fabric/README.md
The agent adds a skill per command. Then type @techfabric-write-post. None of them belongs in an automation: the daily run uses the techfabric-blog skill, which never publishes.
For example
@techfabric-write-post today's brief
For TechFabric authors
Daily drafts from your coding agent
Your agent can start a post for you every weekday at 9am. The server picks one topic a day from the news and the searches we want to answer, matches it to what you write about and holds it for you for a day. Your agent drafts it from your repositories and leaves you questions for the first-hand part. You add that, read it and decide whether it goes out.
Step 1
Take today's brief
At 9am on weekdays your scheduler starts your agent with the techfabric-blog skill. The agent calls get_brief, which picks today's topic and holds it for you for 24 hours: a news story from the last two days, or a search we don't answer yet that matches your work. If today's post has gone to a colleague, the pace of one automated post a day and three a week is used up, or nothing fits, it says why and stops.
Step 2
Draft from your own work
The agent reads the editorial_rules resource and drafts from the brief and the repository the run starts in. It asks you for what only you know, such as what broke or a number you measured. On an unattended run it writes in TechFabric's "we'd" voice and lists its questions for you beside the links.
Step 3
Lint, fix and submit
The agent runs lint_draft and fixes what it reports until it passes, reviews the draft against the judge_rubric it returns, then calls submit_draft with the brief's id. The post is filed under your byline and the site builds the preview. A scheduled run stops there: the skill tells it never to publish, and the Claude Code and Codex schedules below leave publish_draft out.
Step 4
Review and publish
The run ends with the preview link and the agent's questions, in its session or, for a run from cron, in its log. You read the preview and answer what the agent asked. Then, in a session with you, the agent verifies it with check_draft and calls publish_draft, which asks you to confirm. Or use the editor link from the preview email. Nothing is published until you say yes.
Schedule it in your agent
Fabric Agents
Each weekday the run opens its own session, waits for you to allow its tools, and ends in Needs Review with the preview link.
Paste this into a Fabric Agents session:
Set up TechFabric daily drafts in this workspace: follow https://www.techfabric.com/mcp-servers/daily-drafts/fabric-agents.md
The agent adds techfabric.com's MCP server as a source, the techfabric-blog skill and an automation that runs at 9am on weekdays in your time zone, with the model connection you already use. Then authenticate the TechFabric source and sign in with your @techfabric.com account. The automation runs in Ask mode, so each run waits for you to allow its tools. Switch it to Execute if you want it to run without asking.
Claude Code
A Desktop scheduled task, or a cron line for the CLI.
curl -fsSL https://www.techfabric.com/mcp-servers/daily-drafts/install.sh | sh -s -- claude-code
Then run /mcp, pick techfabric, choose Authenticate and sign in. In Claude Desktop's Code tab, open Scheduled and add a local task on Weekdays at 9:00, in one of your repositories, with this as its instructions. Choose Run now once and always allow the techfabric tools.
Draft today's TechFabric post with the techfabric-blog skill.
Without Desktop, a crontab line does the same and leaves the preview link and its questions in the log:
0 9 * * 1-5 cd ~/your-repo && claude -p "Draft today's TechFabric post with the techfabric-blog skill." --allowedTools "mcp__techfabric__get_brief mcp__techfabric__lint_draft mcp__techfabric__submit_draft mcp__techfabric__get_status mcp__techfabric__search mcp__techfabric__get_page mcp__techfabric__list_posts Read Grep Glob" >> ~/techfabric-daily-draft.log 2>&1
Codex
A crontab line runs codex exec, read-only on your computer.
curl -fsSL https://www.techfabric.com/mcp-servers/daily-drafts/install.sh | sh -s -- codex
The skill goes in ~/.agents/skills, where Codex reads personal skills (a Codex older than 0.95 gets ~/.codex/skills instead). Then run codex mcp login techfabric and sign in. Add this line to your crontab, with your own repository's path. The run is read-only on your computer, writes only through the MCP server, and leaves the preview link and its questions in the log.
0 9 * * 1-5 cd ~/your-repo && codex exec --sandbox read-only -c 'mcp_servers.techfabric.disabled_tools=["publish_draft","revise_post"]' "Draft today's TechFabric post with the techfabric-blog skill." >> ~/techfabric-daily-draft.log 2>&1
Each one installs the same techfabric-blog skill and runs on the cron schedule 0 9 * * 1-5, 9am on weekdays in your own time zone. Sign in first, as in set up your AI harness, so the scheduled run doesn't stop at a sign-in.
Privacy
What do TechFabric's MCP servers keep about you?
Reading keeps nothing about what you ask. It needs no account and sets no cookie, and the only thing stored is a per-IP call count for the rate limit. Authors who sign in to write leave their drafts and address.
Neither server keeps what you searched for or read. The log line for a call names the tool and the protocol revision, never its arguments.
The only thing stored about an anonymous caller is a count of calls per IP address for the rate limit, which expires after about an hour.
No read call reaches a language model on our side. Both servers answer from an index built when the site was deployed, and the Field Guide's server makes no outbound request at all.
When a TechFabric author signs in to write, the server keeps the text they check, file or save, with their address against it, as the browser editor does.
MCP, the Model Context Protocol, is an open standard for connecting AI assistants to other systems. An MCP server publishes a list of tools with their parameters, and an assistant such as Claude, Codex, Cursor or VS Code's agent mode calls them partway through a task and gets structured answers back.
A remote server like ours is a single URL, so connecting one is a line of configuration and nothing to install.
What is the techfabric.com MCP server for?+
Writing. TechFabric's engineers use it to draft blog posts and case studies from the coding agent they already use, such as Fabric Agents, Claude Code or Codex, with the repository and context that agent already has.
The agent runs the site's checks, files the draft under the engineer's byline and, once the engineer reads the preview and confirms, publishes it. Anyone can also search and read the site's published pages without signing in.
Do I need an account to use TechFabric's MCP servers?+
No. Every read tool on both servers works without signing in, and neither server sets a cookie. The only sign-in is on techfabric.com's write tools, which are for TechFabric's own blog authors and ask for a Microsoft account in the techfabric.com tenant.
Can an agent publish to techfabric.com through the MCP server?+
Yes, an author's own agent can, for that author's own draft, once the author confirms.
publish_draft needs the site's full checks to have passed on exactly the saved text, and its first call publishes nothing: a client that can ask the author does, naming the post; otherwise the agent gets a one-time confirmation and is told to ask them before sending it back.
The post then goes through the editor's own Publish, and the approval records how the author confirmed. Anyone who isn't on the blog's author list can't reach the write tools at all, and the Field Guide server has no publish tool.
Can I change a post that's already published?+
Yes, if it's yours. Your agent calls revise_post with the post's URL, which opens a revision whose first draft is the live text, with its own preview.
It edits, checks and publishes that revision with the same tools as a new draft, and publishing replaces the live post at the same URL, under the same byline, with its original date and an Updated line. Only the post's author or the blog's editor can open one. Without an agent, ask for an Edit this post link at techfabric.com/api/ideas/revise.
Is the Field Guide server Databricks' own MCP server?+
No. Databricks runs its own managed MCP servers inside a workspace, which act on your data and are documented on docs.databricks.com. The Field Guide server is built and run by TechFabric, a Databricks partner. It answers Databricks questions from our guide, with code and the documentation links each section cites, and it never connects to a workspace.
How current is the Databricks Field Guide server?+
Its index is rebuilt on every deploy of the guide, so a new margin note or a rewritten chapter is in the server's answers as soon as that deploy is live.
Each answer carries the commit that built it, when each page last changed, and how long a client may cache it. For exact syntax and limits, follow the docs.databricks.com links it returns, because Databricks' own documentation is the authority and the guide links to it instead of copying it.
What happens if my agent goes over the rate limit?+
The server answers HTTP 429 with a Retry-After header, and the agent can try again after that. techfabric.com allows 300 anonymous calls per IP address per hour. The Field Guide allows 60 a minute and 300 an hour per IP address.
Are TechFabric's MCP servers in the official MCP Registry?+
Both are. techfabric.com is listed as com.techfabric/techfabric and the Field Guide as com.techfabric.databricks/field-guide, and Glama lists both as connectors. A client that browses the registry finds them under those names, and the domains behind each name are proved by a key served from that domain.
