Onboard-Context-Matic

# Onboarding: ContextMatic MCP

This skill delivers a guided, interactive tour of the `context-matic` MCP server. Follow every

phase in order. Stop after each interaction point and wait for the user's reply before continuing.

> **Agent conduct rules — follow throughout the entire skill:**

> - **Never narrate the skill structure.** Do not say phase names, step numbers, or anything that

> sounds like you are reading instructions (e.g., "In Phase 1 I will…", "Step 1a:", "As per the

> skill…"). Deliver the tour as a natural conversation.

> - **Announce every tool call before making it.** One short sentence is enough — tell the user

> what you are about to look up and why, then call the tool. Example: *"Let me pull up the list

> of available APIs for your project language."* This keeps the user informed and prevents

> silent, unexplained pauses.

---

Phase 0 — Opening statement and tool walkthrough

Begin with a brief, plain-language explanation of what the server does. Say it in your own words

based on the following facts:

> The **context-matic** MCP server solves a fundamental problem with AI-assisted coding: general

> models are trained on public code that is often outdated, incorrect, or missing entirely for newer

> SDK versions. This server acts as a **live, version-aware grounding layer**. Instead of the agent

> guessing at SDK usage from training data, it queries the server for the *exact* SDK models,

> endpoints, auth patterns, and runnable code samples that match the current API version and the

> project's programming language.

After explaining the problem the server solves, walk through each of the four tools as if

introducing them to someone using the server for the first time. For each tool, explain:

- **What it is** — give it a memorable one-line description

- **When you would use it** — a concrete, relatable scenario

- **What it gives back** — the kind of output the user will see

Use the following facts as your source, but say it conversationally — do not present a raw table:

> | Tool | What it does | When to use it | What you get back |

> |---|---|---|---|

> | `fetch_api` | Returns an exact match for an API `key`/identifier and language, or lists all APIs for a given language. The `key` is the machine-readable identifier returned by `fetch_api` (for example, `paypal`), not the human-readable display name (for example, "PayPal Server SDK"). | "What APIs can I use?" / Starting a new project / "Do you have the PayPal SDK?" | A named list of available APIs with short descriptions (full catalog), or one exact API match when you provide its identifier/key and language |

> | `ask` | Answers integration questions with version-accurate guidance and code samples | "How do I authenticate?", "Show me the quickstart", "What's the right way to do X?" | Step-by-step guidance and runnable code samples grounded in the actual SDK version |

> | `model_search` | Looks up an SDK model/object definition and its typed properties | "What fields does an Order have?", "Is this property required?" | The model's name, description, and a full typed property list (required vs. optional, nested types) |

> | `endpoint_search` | Looks up an endpoint method, its parameters, response type, and a runnable code sample | "Show me how to call createOrder", "What does getTrack return?" | Method signature, parameter types, response type, and a copy-paste-ready code sample |

End this section by telling the user that you'll demonstrate the four core discovery and

integration tools live during the tour, starting with `fetch_api` right now. Make it clear that

this tour is focused on those core ContextMatic server tools rather than every possible helper the

broader workflow might use.

---

Phase 1 — Show available APIs

1a. Detect the project language

Before calling `fetch_api`, determine the project's primary language by inspecting workspace files:

- Look for `package.json` + `.ts`/`.tsx` files → `typescript`

- Look for `*.csproj`