Skip to content

workshop.md

Latest commit

 

History

History
258 lines (194 loc) · 11.5 KB

workshop.md

File metadata and controls

258 lines (194 loc) · 11.5 KB
Raw
published true
type workshop
title Context > Models: How to make your agents truly intelligent
short_title Context > Models
description Plan a cupcake order with GitHub Copilot and discover why the right context matters more than which model you use. Hands-on with Foundry IQ, Fabric IQ and MCP.
level beginner
authors
Marc Teipel
contacts
@marcteipel
duration_minutes 60
tags GitHub Copilot, MCP, Foundry IQ, Fabric IQ, Azure, context engineering
navigation_levels 2
navigation_numbering true

Welcome

WeAreDevelopers 2026 · Berlin · ~60 minutes

Strong agents are not defined by the model they use, but by the context they can access and the systems they can act on. In this lab you'll feel that difference firsthand — by planning a cupcake order for this very workshop. 🧁

This is a MoaW workshop. The best way to read it is rendered:

👉 Open the workshop on MoaW

Or read the raw markdown: docs/workshop.md

You'll interact with AI trough GitHub Copilot. We will ask the same question multiple times, each time adding one thing and watch the answer transform:

Round What you add What can happen
1 Nothing (model only) Copilot guesses — plausible, but wrong for our event
2 Foundry IQ (org knowledge) It learns our rules: nut-free venue, dietary minimums, approved suppliers
3 Business data (Fabric IQ-style) It learns our numbers: confirmed headcount, budget, past consumption
4 A different model The answer barely changes — because context, not the model, was doing the work

Then you place the order — and claim a real cupcake (if you have a friendly facilitator) 🎉

Setup (5 min)

You need: a GitHub account with GitHub Copilot enabled (provided at the workshop) and a browser.

  1. Open this repository and click Code → Codespaces → Create codespace on main - then all dependencies are preloaded.
  2. Wait for the devcontainer to build (Node 20 + Azure CLI + the Copilot extensions install automatically). When the terminal shows the dependencies installed, you're ready.
  3. Open the Copilot Chat panel (Ctrl/Cmd + Alt + I) and switch the mode dropdown from Ask to Agent.

Stuck at any point? There's a fully preconfigured branch. Run git switch mcp-ready in the terminal, reload, and skip the setup steps. See Troubleshooting.

Round 1 — Just the model (5 min)

Open a new chat (so there's no leftover context) and pick a model, ask Copilot, in Agent mode:

I'm organising a developer workshop in Berlin and want to order cupcakes for the
attendees. Plan the cupcake order for me: how many, which types, which bakery, and
what will it cost? Don't take into account this repo's content — just use your own knowledge.

Read the answer and note it down. Copilot will produce something reasonable-sounding — a round number of cupcakes, generic flavours, maybe an invented bakery and price.

But: Where did those numbers come from? How many of the details are actually true for our event? (Spoiler: none of them. The model is pattern-matching, not informed.)

This is the baseline. A capable model with no context can only guess.

You can also change the model Copilot uses and ask the same question again. The answer might be different.

Round 2 — Add organizational knowledge with Foundry IQ (15 min)

Foundry IQ is a knowledge base built on Azure AI Search. With it you can give Agents context from documents like PDFs, Word documents, and others. Ours has been pre-loaded with this event's organizational knowledge: the dietary & allergen policy, the Berlin venue operations guide, the approved supplier catalogue, and an ordering playbook. It exposes an MCP endpoint that Copilot can call directly.

You can look at the content in the knowledge folder in this repo. In this case these markdown files (md) with the content and were preuploaded to a blob storage in Azure. Go to the azure portal https://portal.azure.com/, login with the lab's account details and try to find the files there.

Now give Copilot access to that knowledge.

  1. Create the config file. In the folder .vscode, create a new file named mcp.json.

  2. Paste this into .vscode/mcp.json and save (Ctrl/Cmd + S).

  • Replace only the value of "url" with the FOUNDRY_IQ_MCP_URL from the facilitator.
  • Do not paste the api-key into the file; leave "${input:foundry-iq-key}" exactly as it is.
  • You will paste the real api-key later, when VS Code prompts you after you click Start.
{
  "inputs": [
    {
      "id": "foundry-iq-key",
      "type": "promptString",
      "description": "Foundry IQ query api-key (from the Azure Portal)",
      "password": true
    }
  ],
  "servers": {
    "foundry-iq": {
      "type": "http",
      "url": "<FOUNDRY_IQ_MCP_URL from the facilitator slide>",
      "headers": { "api-key": "${input:foundry-iq-key}" }
    }
  }
}

  1. Get the Foundry IQ api-key Navigate to portal.azure.com, login with the lab's account details, open resource group, open the search service, in the left menu open Keys. Look under Query keys, not Admin keys. Copy the query key and keep it handy.

  2. Start the server. Right after you save, a small ▶ Start link appears just above the "foundry-iq" line inside the file — click it.

    • Don't see it? Open the Command Palette — VS Code's command search box. Press Ctrl + Shift + P (Windows/Linux) or Cmd + Shift + P (Mac), or use the top menu View → Command Palette…. A box appears at the top of the window; type MCP: List Servers, press Enter, choose foundry-iq, then Start.
    • When prompted, paste the api-key you copied and press Enter.

  3. Turn the tool on. In the Copilot Chat panel, click the tools icon (🔧) and make sure knowledge_base_retrieve is checked.

Now ask the same question as Round 1 again (new chat), but with a small hint for Copilot to use its tools

I'm organising a developer workshop in Berlin and want to order cupcakes for the
attendees. Plan the cupcake order for me: how many, which types, which bakery, and
what will it cost? Don't take into account this repo's content - use your tools.

Watch what changes. Copilot now grounds its answer in real rules — for example: the venue is nut-free, at least 30% vegan and 15% gluten-free, order from an approved Berlin supplier, respect the 48-hour lead time, plan ~1 cupcake per attendee.

If Copilot does not use the tool be specific. Tell it to use tool knowledge_base_retrieve. Then ask a follow-up to see grounding in action:

Which supplier must we use given the nut-free venue, and why not the cheapest one?

The model didn't change, but it got informed.

Round 3 — Add business data (Fabric IQ-style) (15 min)

Rules aren't enough — you still need the numbers. Those live in a business-data system and can be added to your agent with Foundry IQ. In this lab a small MCP server (cupcake-context) serves the confirmed figures: registered vs. confirmed attendees, dietary-requirement counts, the catering budget, and historical consumption by flavour. (This is a stand-in for Fabric IQ; see docs/fabric-iq.md to point Copilot at the real Fabric IQ data agent.)

Do you want to see the numbers first? You can go to data - fabric and browse through the csv files the team created. These here is a small sample of data. If you want to connect your data platform FoundryIQ can be used for that. This is a bonus exercise at the end to create a real Fabric connection with the Fabric Data Agent. But first:

Add a second server to your .vscode/mcp.json, inside "servers":

"cupcake-context": {
  "type": "stdio",
  "command": "node",
  "args": ["${workspaceFolder}/mcp-server/src/index.js"]
}

Too complicated? Ask Copilot to do it for you.

Start it (Start above the server), then confirm the query_business_data tool is enabled in the tools picker. Ask the same question again — and this time push for precision:

Plan the cupcake order using our confirmed attendee numbers, dietary counts and budget.
Give me exact quantities per type, the supplier, and the total cost. Stay within budget.
Use your tools to get the real numbers, and cite what you used.

Sometimes Copilot already has access to that information from this repo. Be specific if you want it to use this certain tool.

Watch what changes. The plan becomes exact: the confirmed headcount, the vegan/gluten-free/halal counts (reconciling the policy minimums with the real requests), a total that fits the budget, and a flavour split informed by what actually got eaten at past events (chocolate sells out; lemon gets left over).

This is a grounded, predictable, reliable answer — the goal of this workshop.

Round 4 — Now change the model (8 min)

Keep everything connected and open a new chat with the same prompt from Round 3. Before sending, use the model picker at the bottom of the Chat box to switch to a different model (e.g. switch between Claude Sonnet, GPT-5

  • whatever your Copilot plan offers). Run it on two or three different models.

Watch what does not change. The core of the answer stays the same: same supplier, same quantities, same budget-safe total. Wording and formatting differ; the substance doesn't.

The takeaway: once the agent has the right context, the specific model matters far less than people think. Swapping to a "fancier" model barely moved the needle — but adding context in Rounds 2 and 3 transformed the answer completely.

Context > Models. Invest your effort in what the agent can know and do, not only in which model it runs on.

Finale — Place the order 🧁

Tell Copilot to place it:

Place the cupcake order with the plan above.

Copilot calls the place_cupcake_order tool. It validates the order against the nut-free rule and the budget, then confirms it and prints a claim code.

Take your claim code to the catering table and claim your cupcake. You earned it. 🎉

(If the tool rejects the order, read why — it's enforcing the same rules and numbers you just learned. Fix the plan and try again. That's grounding protecting you from a bad order.)

Wrap-up

  • A model with no context guesses. The same model with the right context is grounded, predictable and reliable.
  • Foundry IQ gave Copilot your organization's knowledge (rules, policies, docs).
  • Fabric IQ (here, a stand-in) gave it your business data (the numbers).
  • MCP is the plug that connects an agent to that context and to systems it can act on.
  • Changing the model was the least impactful change you made today.

Everything you did applies to any coding agent, not just GitHub Copilot.

Troubleshooting

  • "I can't get MCP configured." Run git switch mcp-ready, reload the window, and the servers are already defined — just Start them and toggle tools per round.
  • The foundry-iq server won't connect. Re-check the URL and that you pasted the api-key exactly. Use "MCP: List Servers" → Show Output to see errors.
  • Copilot answers without calling a tool. Open the tools picker (🔧) and make sure the tool for that round is enabled; explicitly ask it to "use the knowledge base" or "use the business data".
  • cupcake-context won't start. In the terminal: cd mcp-server && npm install, then Start the server again.