Skip to content

Lab 1 - Your First Conversation with a Network

Seat time

Approximately 45 minutes. Roughly half of that is reading — this lab carries the concepts the rest of the guide builds on — and the rest is hands-on, with prompts against a live Meraki organization. The agent takes a few seconds to a minute to answer each one, and several steps ask you to open up the tool calls behind an answer rather than just read it.

For most of the history of network operations, getting an answer out of a device or platform meant knowing where to look — and the exact words to ask in. Which show command, and whether this vendor calls it show interface or show interfaces, and which flag narrows it down. Which dashboard page, which filter. Which API endpoint, which query parameter, which field in the JSON that came back.

The knowledge that made you fast was knowledge of where things are and what syntax each platform insists on, and almost none of it transferred. A new vendor meant learning the same facts again in a different dialect, and a command you had not typed in six months meant a trip to the documentation.

That is the part of the job the AI era is changing. Most of the time in an incident goes not on analysis but on translation: turning "the branch feels slow" into the right pages, commands and endpoints, then turning the results into something you can act on. That translation can now be delegated. The interfaces are still there, but you no longer have to be fluent in them — your expertise shifts from knowing where to look towards judging which question matters and whether the answer is right.

Several advances make that possible, and the biggest is in the models. Frontier large language models (LLM) are now good at reasoning and inference: they can work out what a vague question is really asking and assemble an answer from results in different formats. Give a model the ability to act — call something, read the result, decide the next step — and you have agentic AI. Applied to running networks, that is AgenticOps.

An agent still needs a way to reach your platforms, and that is the narrower job of the Model Context Protocol: an open standard, introduced by Anthropic in 2024 and now under the Linux Foundation, for how an AI agent accesses applications and data. It replaces the custom connector previously needed for every pairing of platform and AI client.

An MCP client and an MCP server exchanging initialization, requests, responses and notifications
MCP, the open standard for connecting AI applications to external data and tools.

The diagram below shows how the pieces fit. The host is the AI application or agent you talk to, and it runs one MCP client for each server it connects to. Each MCP server publishes a platform's capabilities in three forms: tools the model may call, resources it may read for context, and prompts, reusable templates offered to the user (MCP specification). Behind the server, it reaches the platform through whatever that platform already speaks — a REST API, a file system, a database. In this lab the host is the lab tool, and the two servers are Meraki and ThousandEyes. The lab tool uses only the servers' tools, not their resources or prompts, so tool calls are what you will watch.

A host application with three MCP clients, each connected to an MCP server for Meraki, ThousandEyes, and other platforms
One host, many servers: each MCP client connects to one server, and each server reaches its platform through that platform's own API.

Put simply, the reasoning comes from the model and the reach comes from MCP. Because that reach is a standard, the same two Cisco-hosted MCP servers will also work unchanged in your own AI client in Lab 3.

Now see it for yourself. You will start with the host on its own, with no server connected, to see what the model can and cannot answer. Then you will connect the Meraki MCP server and ask again, and follow the whole chain: your question, the agent's reasoning, the tools it calls, and the answer it assembles from a live Meraki organization.

Steps

  1. Open https://agenticops.merakitraining.net and sign in with the username and password your proctor sent you.

    Note

    Your username is a short name like pod07, not an email address. If sign-in fails, check that you have not accidentally pasted a trailing space along with the password.

    The first time you sign in, an AI can make mistakes notice appears before anything else. Read it, then click I understand.

    The AI can make mistakes notice: the lab runs a smaller, faster model with limited reasoning, so check what each answer rests on by expanding its tool calls, and treat the lab guide as the authority; an I understand button closes it
    The notice shown at first sign-in.

    It says something this guide will keep coming back to: some answers will sound right and be wrong, and the way to tell is to check the tool calls behind them. The notice appears only once, but the same text is always one click away under AI can make mistakes in the right-hand column.

  2. Take a moment to look at the interface before you type anything.

    The AgenticOps Lab interface on a new account: an empty conversation window with the message box below it, the UTC clock, time left and pod name at the top right, and a right-hand column with About this lab, the token budget, Lab check-in buttons for Labs 1, 2 and 3, New Chat, MCP server settings reading no tool server, and the prompt library
    The lab tool on a new account, before any MCP server is connected.

    • The conversation window takes up most of the screen. You type in the message box at the bottom: Enter sends, and Shift+Enter starts a new line. The line beneath the box shows which tool servers are connected, and for now it prompts you to choose one. Under each answer, 👍 and 👎 let you mark it as helpful or wrong; click the same thumb again to take it back. The lab team reads these, and the assistant does not.
    • The top right corner shows the current time in UTC, how long your lab account has left and which pod you are signed in as, beside Logout. Meraki and ThousandEyes report times in UTC, and so does the agent, so the clock is how you tell whether "14:32 UTC" was a few minutes ago or this morning. Hover over it to see your local time.
    • The right-hand column holds the controls you will use throughout the labs:
      • About this lab, with the AI can make mistakes notice and your Token budget, which shows how many tokens you have used so far.
      • Lab check-in, one button per lab, for telling us how each lab went once you finish it.
      • New Chat, under Conversations, which starts a fresh conversation and keeps the current one. Lab 2 begins with it.
      • MCP server settings, collapsed for now, where you connect the Meraki and ThousandEyes servers and paste their keys.
      • Prompt library: type / in the message box, or click / Prompts beneath it, for ready-made prompts grouped by topic. Picking one fills the box so you can edit it before sending.

    Look at the summary beside the MCP server settings header. It reads no tool server, in amber, because your account was handed to you with nothing connected. You will connect the Meraki server in Step 4, after first seeing what the assistant can do without it.

    Information

    The token budget limits how much you spend, not how long you have. It resets when your lab is issued. A normal pass through Labs 1 and 2 uses a fraction of it, so you do not need to ration your questions.

  3. Before you connect anything, find out what the assistant can and cannot tell you on its own. Ask it something that can only be answered with live data from your organization:

    How many Meraki networks are in my organization?
    

    This is the baseline you will compare everything else against, and the answer comes straight from the model. The wording varies, but expect something like "I don't have access to your Meraki organization or its networks", followed by general advice on how you could find out yourself. With no tool server connected, the model has no route to any Meraki dashboard, so the most it can offer is what it already knows.

    Note

    The assistant declined rather than guessing — partly because this lab instructs it to, and partly because of how the model was trained. Not every model or AI tool behaves that way: a model with no data source and no such instruction can produce fluent, plausible, entirely invented numbers. Once the MCP server is connected you can see the tool calls sitting behind a claim, and that is what lets you tell a retrieved fact from a generated one.

    Now ask something that needs no live data at all:

    What is a Meraki MX, and what is the difference between a Meraki network and a Meraki organization?
    

    That one it handles well. Meraki is a widely documented product, so the model learned a great deal about it during training and can explain it fluently without touching an API.

    Hold those two results side by side, because the gap between them is the entire reason MCP exists. The model already knows Meraki as a subject. What it has no way to know is your Meraki — how many networks you run, what is offline this minute, which SSID somebody changed this morning. No amount of model capability produces that, because it is not knowledge; it is current state, and it has to be fetched.

  4. Connect the Meraki MCP server. Click MCP server settings to expand the panel, then:

    1. Under Meraki MCP Server, select Official Meraki MCP server (Cisco-hosted).
    2. A Meraki Dashboard API Key field appears. Paste in the key from Get the Meraki read-only API key, just below this step.
    3. Click Save Settings.
    Get the Meraki read-only API key

    Open the Meraki read-only API key and copy it from there.

    Important

    Paste only the read-only lab key linked above. Never enter a personal, production or customer API key into a shared training tool — the sidebar warns you about this too, and it is the one mistake in this lab that could follow you out of the room. Don't paste the lab key into Webex, email or a feedback form either — if you share a screenshot or a config file for troubleshooting, blank out the key first.

    The API key and token in this guide are only for this lab's use. Please DO NOT use them for any other purpose. The Cisco team rotates these keys from time to time in case of any misuse.

    Shared key, shared rate limit

    Everyone in this lab uses the same key, and the Meraki Dashboard API limits each organization to about 10 requests per second, however many people are asking. If the assistant reports an error with code 429 (Too Many Requests), nothing is wrong with your setup: wait a minute and try again.

    You should see ✓ Settings saved, and the key field collapse to ✓ API key saved with a Change button beside it. Collapse the panel and the summary no longer reads no tool server in amber — it reads Meraki.

    Information

    The Meraki MCP server can be deployed in two ways:

    • Cisco-hosted — Cisco runs it at https://mcp.meraki.com/mcp. There is nothing to install: a client points at that URL and authenticates with a Meraki API key. This is the one you just connected.
    • Self-hosted — the same server as open-source code that you run on your own machine or infrastructure. Choose it when you want to customize the server, keep API calls originating from your own network, or reach Meraki environments the hosted server does not cover, such as the US government cloud and the localized regional environments.

    Note

    Leave the ThousandEyes switch off for now. You will turn it on in Lab 2, which is where a second tool server starts to earn its place.

  5. Start with a question that only a live connection can answer, and that is about the connection itself:

    Return the identity of the current user, including name, email and authentication details.
    

    This time it can answer. The current user is the Dashboard administrator your API key belongs to, and it names it: RO-user LL. It also describes the account: the email address it signs in with, when it last used the dashboard, and that it has an API key. Nothing about the model changed between Step 3 and now. All you did was give it a way to reach the platform.

    The request for the identity of the current user, followed by four rows between the agent and the Meraki MCP server — a semantic_search request and response, then an execute_api request and response — and the answer naming the administrator RO-user LL with its authentication details
    The whole chain: your question, the tool calls behind it, and the answer. Step 6 reads the rows.

    That administrator owns the read-only key you pasted in Step 4. Every call the agent makes reaches the Dashboard API as that administrator, with that administrator's permissions and nothing more. That is why the lab hands you a read-only key, and why it matters whose key you give an agent.

    Hint

    This is a real API call against a real organization, not a canned response. If you ask the same question in an hour and someone has changed something, the answer changes.

  6. Before asking anything else, look at how that answer was actually produced. Expand the REQUEST and RESPONSE rows sitting above it.

    The color tells you which way each one travelled. A blue REQUEST row is the agent calling out to the Meraki MCP server, and the arrow beside it reads Agent ⟶ Meraki MCP server. A green RESPONSE row is the server answering, arrow reversed. The name on the right of each row is the tool involved.

    Read them as a conversation. In the run pictured above there are four rows. The agent first used semantic_search to ask the server for a capability matching your question, and got back a short, ranked list of capabilities — names and what each one is for, not data. One of them was getAdministeredIdentitiesMe, described as "Returns the identity of the current user." Having picked it, the agent used execute_api to run it, and that second response is where your identity came back.

    Why the prompt is worded that way

    semantic_search matches your words against the descriptions of the capabilities, so wording close to "Returns the identity of the current user" finds getAdministeredIdentitiesMe first. The more natural "Who am I as a Meraki administrator?" does not: in testing it came back every time with the status of a Spaces integration, monitored media servers and appliance uplink statuses — nothing that answers the question — leaving the agent to notice and search again, and occasionally to give up and describe administrator roles in general instead. The search is consistent; it just ranks by what the words resemble, not what you meant.

    If you see more than four rows anyway, nothing is wrong: the agent searched more than once before executing. The number of searches varies; the shape does not. Search, then execute.

    That shape exists because of a design decision in the Meraki MCP server. The Dashboard API is big: close to a thousand operations at the time of writing, over five hundred of them read-only. The obvious approach is to publish one tool per operation, but the model would then face hundreds of choices on every turn, and that list alone would consume much of the context before you asked anything. Instead the server exposes exactly two tools and keeps the operations as data it can search:

    Tool What it takes What it returns
    semantic_search A natural-language query, and optionally top_k to cap the number of results A ranked shortlist of matching capabilities, each with its capability_id, a description and the parameters it needs
    execute_api A capability_id from that shortlist, plus any parameters it requires The live Meraki Dashboard API response, after the server validates the capability

    Two details in the rows you just expanded are worth noticing. Each search returned a shortlist — five capabilities, not the whole catalogue — because answering with every match would defeat the purpose of keeping the model's choices small. And the search responses contained no data whatsoever: they are menus of names and descriptions. Your identity only appeared once execute_api ran the capability the agent picked off the menu.

    Information

    Search plus execute is one of the two most common shapes an MCP server takes, and the choice follows from the API behind it rather than from fashion. Meraki's is large enough that publishing it as tools would swamp the model's choices, so its capabilities live in a searchable catalogue instead. A server fronting a smaller or more focused API has no such problem and will usually publish its capabilities directly, as named tools the model picks from with no search step. You will connect one of those in Lab 2 and can judge the difference for yourself. Neither is the better design; they answer different constraints.

    The shape here does have a consequence for you, and a missed first search shows it. Finding the capability is a search problem, so wording feeds that search: ask for things roughly the way the API describes them and the right capability surfaces, phrase them unlike the catalogue and the search can come back with nothing useful. That search lives inside the Meraki MCP server, over its own catalogue, so it is not something the lab tool adds — it behaves the same way in whatever client you use, including your own in Lab 3. A capable model will phrase better queries and notice when results are useless, but the matching itself is the server's. The last step of Lab 2 comes back to how much your wording drives what the agent fetches; it is worth knowing that it starts this early.

  7. The question that failed in Step 3 was about your organization, so start by finding out which one that is:

    List the organizations I have access to.
    

    It names the organization the key can reach, Meraki Launchpad 🚀, organization ID 537758, usually with a few details such as its dashboard URL.

    The request to list the organizations I have access to, followed by four rows between the agent and the Meraki MCP server — a semantic_search request and response, then an execute_api request and response — and the answer listing Meraki Launchpad with ID 537758 and its dashboard URL
    A search, then getOrganizations.

    Expand the execute_api request: it ran getOrganizations. The search before it was optional, because the agent had already been told about that capability.

    That knowledge came from the server. When a client connects, an MCP server can send back instructions for the agent along with its tools — a short passage of advice that a client can add to the model's prompt (the lab tool does). The Meraki MCP server's instructions tell the agent to call getOrganizations directly to find the organizations a key can reach.

    Information

    Seeing a search first, as in the run above, is normal. The instructions are advice to the model, not a rule anything enforces, and this lab's small model often searches anyway before following them. If you see just two rows, an execute_api for getOrganizations and its response, the agent went straight to the capability it was told about. Either way it ends at the same call, and the rows show you which happened. The instructions come from the Meraki MCP server, not the lab tool, so every client that connects receives the same advice. Whether the model sees it depends on the client, which is worth keeping in mind when you connect your own in Lab 3.

    So the pattern is: for the capabilities its instructions name, the agent can execute directly, and a search first is a wasted step, not a wrong one. For everything else it must search for the right capability in plain language, then execute it. Your prompt is what drives that search.

  8. Now ask something that requires the assistant to make a decision about which data to fetch:

    How many networks are in that organization, and how many of each network type?
    

    You should get the total, then a breakdown by the kinds of product the networks contain — appliance, switch, wireless, camera and so on, which Meraki calls its product types — with how many networks include each one, and usually an offer to list the networks of a particular type.

    Expand the rows and notice how little it took. The server's instructions name one other capability the agent may call directly, getOrganizationNetworks, for the networks inside an organization. You may see a search before it again, as in Step 7. What matters is the call that follows: a single execute_api for getOrganizationNetworks, using the organization ID already in the conversation from Step 7. Both the count and the types were read out of that one result rather than fetched separately, because each network records which kinds of product it contains. You never told it where to find the types, or that "network types" means product types in Meraki's terms. It worked that out.

    Who did the counting?

    Not the model. A language model does not count the way a script does. It reads the response as a stream of text fragments, called tokens, and writes its answer by predicting the next one, with no running tally. Left to count thirty similar-looking networks itself, this lab's model gave different totals on different runs, even though the server's response was exactly the same each time. On a long list it can lose a row or merge two without any sign that it did. A larger model slips less often, but the mechanism is the same.

    So, behind the scenes, the lab app counts the records in each response before it reaches the model and hands the model the totals along with the data, to deliver a deterministic result: the same response always gives the same count. The model explains the answer rather than producing it. That is also why this step asks for totals rather than a list of every network: a count can be done in code, but a list of thirty networks is still copied out by the model, row by row, and in testing it sometimes skipped or repeated rows while giving the right total. That is how work that has to be exact — counts, totals, "every device that…" — is done in production too: in code, before the model. Wherever that is not the case, treat any number a model gives you over a long list as an estimate until you have checked it against the source.

    Learn more: why the Meraki MCP server returns one page at a time

    A count is only as complete as the list it was taken from. Thirty networks fit in one response, but a list like your own organization's devices can run to thousands of entries, so the Dashboard API hands it out in pages. A request can set perPage to say how many entries it wants, and every response carries a Link header pointing to the next page, which the caller follows until there is no next left (Dashboard API pagination). A script never sees that walk: the Meraki Python library follows the links for it when asked for total_pages="all".

    The Meraki MCP server deliberately does not. execute_api returns the first page only, and it rejects total_pages with "Multi-page fetching is not supported." Its open-source code gives the reason: fetching every page "can bloat the agent's context and stall on large orgs" (source). Everything execute_api returns lands in the model's context. A ten-thousand-device organization fetched in full would crowd out the conversation, cost a great deal of tokens and take a long time, so one bounded page is the safe default.

    The server does not leave it there. It passes back the page itself but not the Link header, so a partial page and a complete list look the same, and its instructions tell the agent how to cope: "For paginated API operations, execute_api returns one page only. Request a bounded page size when supported; do not pass total_pages or claim the result represents the complete dataset." If the agent wants more, it may guess the next page's startingAfter cursor from the last entry — "The SDK does not expose the API's next-page link, so treat this cursor as inferred" — keep the page size fixed, stop when a page comes back empty or the cursor stops making sense, and "report the number of pages fetched and whether more may remain." That is advice to the model, not a rule anything enforces, and the server is in beta, so Cisco can change it.

    What that means for you:

    • Watch the request. If the agent set a perPage, expand the response and compare the number of entries with it. A page that is exactly full probably has more behind it.
    • Ask. "Is that the complete list, or one page of it?" is a fair question, and the tool calls let you check the answer, including how many pages it fetched.
    • Narrow the question rather than fetching everything. Many operations filter on the server: ask for offline devices only, or for one network, and the result is small enough to fit on a single page. Asking for less is how you get a complete answer from a server that returns one page.
  9. So far every question has had an answer sitting in Meraki. This time give the agent a problem instead, phrased the way a ticket would phrase it:

    Users on the San Francisco(network id: L_646829496481100388) network report intermittent slowness in the past 24 hours when accessing our private application, https://app.merakitraining.net. Identify the possible root causes.
    

    This step is meant to fall short

    Send this prompt once and read what comes back. Do not re-send it or ask the agent to try harder: the evidence this ticket needs is not in Meraki, so no rewording will produce it. That gap is what this step shows, and Lab 2 is where you close it.

    The network ID is there because the organization has more than one network with San Francisco in its name — the getOrganizationNetworks response from Step 8 shows three. It tells the agent exactly which site the ticket is about, so it does not have to guess.

    Expect the agent to work harder than in any step so far. It searches several times for what Meraki can measure about a site, then reaches for the nearest thing it can find: usually the status of the MX uplinks, sometimes wireless latency. Several calls may come back as error rows — a parameter name the agent guessed, a time range in the wrong unit — and it may even repeat one that already failed before moving on. Then it gives you a confident, well-organized list of candidate causes — a WAN failover, congestion or QoS, a firewall or traffic-shaping rule, slow TLS handshakes, the ISP's routing, the application's own servers. Each is plausible. None is established by what it actually retrieved. Expand the rows and you will often find the uplink figures it quotes cover the whole organization, not San Francisco alone, even though you gave it the network ID.

    Note

    Notice what never happened: the agent never measured app.merakitraining.net. Nothing it retrieved — device status, uplink state, perhaps wireless latency — describes how that application performs or what path its traffic takes once it leaves the site. That is a limit of the evidence in front of it, not of Meraki as a product: Meraki Insight, for example, adds application-health monitoring on networks licensed for it, and you will meet one of its features in Lab 2. So the agent measured the nearest thing it could reach and reasoned outwards — which is exactly how a plausible answer comes to rest on evidence that does not support it. This is the failure mode to watch for in your own work: ask what a conclusion rests on, and treat a confident answer with no retrieved evidence behind it as a hypothesis rather than a finding.

    Now read what it asks for, because it diagnoses the gap itself. Its suggested next checks and "data that would help" are about the path from the site to the application: latency and packet loss hop by hop, response times from the application's side, perhaps a synthetic test or a traceroute. It may even name ThousandEyes, though nothing in this conversation is connected to it. None of that is in Meraki's view of the site, and no rewording of this prompt will put it there.

    That is the point of this step. Some problems cannot be solved from a single source, however capable the agent. Meraki sees the network you own and manage; the slowness may live in networks you do not, between the site and the application. In Lab 2 you connect ThousandEyes, which measures exactly that path, and at the end of it you will hand the agent this same ticket again with both servers connected — and compare what it can establish then with what it could only suggest here.

    Hint

    Two habits worth taking from this. When an answer disappoints, do not conclude the tool cannot do it — re-ask with the scope, the time range and the grouping you want, and say what a good answer would look like. But learn to tell that apart from a gap in the data itself: when the agent keeps asking for evidence it has no tool to reach, a better prompt will not help, and a second source will.

    And know what the conversation is doing for you. Everything said so far is re-sent to the model on every turn, which is why it could use the organization and networks from earlier steps without looking them up again. The same history has a cost: after a few large results and a couple of false starts it has a great deal to wade through, and it will keep reaching back to earlier answers. When a conversation has wandered that far, New Chat in the sidebar starts a clean one, at the price of the agent having to look everything up again.

Congratulations on completing lab 1!

You have connected the Cisco-hosted Meraki MCP server to an AI assistant and queried a live Meraki organization in plain language. Along the way you have seen that:

  • The agent acts as the administrator who owns the key. Every call reaches the Dashboard API with that administrator's permissions and nothing more, which is why the lab gives you a read-only key.
  • The Meraki MCP server exposes two tools, not hundreds. semantic_search finds the right capability in a catalogue of close to a thousand API operations and returns a menu, not data; execute_api runs the capability the agent picks and returns the live response. When a search misses, the agent rewords it, which is why your wording matters.
  • The server's instructions can make the search unnecessary. For the capabilities they name, such as listing organizations, the agent can go straight to execute_api. They are advice, not a rule, so a search first is a wasted step, not an error. The tool rows show you which happened.
  • One source has limits. Meraki sees the network you own and manage. Asked about a slow application, the agent measured what it could reach, built a plausible diagnosis that the evidence did not support, and asked for path data Meraki does not have — which is what Lab 2 adds.

And you have practised the most important habit of all: ask what an answer rests on, and check the tool calls behind it.

Check in

Before you move on, click Lab 1 under Lab check-in in the right-hand column. Say how confident you feel on a scale of 1 to 5, and add a comment if anything confused you. It takes ten seconds and is how this lab gets better.