What you will take away from this lesson
In 201 - Anatomy of a Plexara MCP, we laid out what is in the box on a Plexara server: the base MCP primitives (tools, resources, prompts) and the Plexara-specific subsystems (semantic enrichment, memory, knowledge, governance) layered on top. This lesson is the user-side companion: what actually happens on your first day, from connecting your client (Claude Desktop, Cursor, or anything else MCP-compatible) to typing your first question and getting back a grounded answer.
The lesson is built around one stubborn fact of first-day use: the agent does not automatically know that this Plexara MCP is the right place to look for an answer. A small habit on the first turn resolves that, and from then on the session carries the context forward.
Learning Objectives
- 01Describe what happens on your first session with Plexara connected, from the first question to the first grounded answer.
- 02Recognize the "generic answer" failure mode and the small prompt cue that resolves it.
- 03Know that platform_info is a gated first call every session, and what it loads into the context window.
- 04Name the three-step discover-query-enrich workflow the agent follows on your behalf, and where each step is covered in the rest of the 200 series.
- 05Understand what carries forward inside a session, across sessions through memory, and what requires the admin-reviewed knowledge pipeline.
Where we are in the curriculum
The 100 series is the foundation for the entire 200 series. If anything in this lesson references a term you have not seen (tokens, context window, agent loop, MCP as an application layer), back up one link.
100 Series: the foundation
- 101What is a Large Language Model?Brilliant at language, blind about your data. Tokens, hallucination, the grounding problem.
- 102Tokens and your budgetSubscription-plan economics, session limits, and Plexara enrichment dedup.
- 103Context, compression, and memoryThe keep / compress / clear playbook and how memory carries across sessions.
- 104Frontier models, specialized models, and why enterprise AI uses bothThree knowledge sources (training, web search, tools). MCP as the exposure protocol.
- 105What is an AI agent?The think/call-tool/observe loop. Professor's knowledge, child's literalism.
- 110Is MCP just an API wrapper?MCP as an application layer. Spectrum from thin wrapper to full application server.
If a term in this lesson looks unfamiliar, back up to the 100 series. The 200 series assumes that mental model. Every row above is a direct link.
Day one: you open your client and ask a question
Picture the setup. Your organization runs a fully managed Plexara workspace. You have been granted access. You point Claude Desktop, Cursor, or whatever MCP-capable client you use at the workspace endpoint, and the Plexara MCP shows up in your client's tool list. The connection is done. You type your first question.
The question most people would ask is the one that sounds natural: "How are sales doing?" What happens next is not what a new user usually expects. Before any Plexara tool runs, the agent has to decide that consulting a tool is the right move for this question at all.
First try without a cue
"How are sales doing?"
What happens
The agent has the Plexara tool list available but no signal that this question is about your organization. Training data covers "sales" as a general topic, and the answer the model produces is the most probable interpretation of a general question.
Result
A coherent paragraph about macroeconomic conditions, consumer spending trends, and seasonal retail patterns. Readable. Plausible. Completely unrelated to your company.
Same question with a two-word entity cue
"How are ACME Corp sales doing?"
What happens
The agent scans the tool list, sees a Plexara MCP named and tagged for ACME Corp, and treats the entity match as a direct signal to consult this server. A compliant agent then calls platform_info on its own, because the tool's own description flags it as the mandatory first call.
Result
platform_info loads the ACME Corp operating manual. The agent now has tenant context, toolkits, and a prescribed workflow. The answer it produces is grounded in ACME Corp's actual sales data, with the tables and aggregation methods named.
Installing the MCP is not enough
Having a Plexara MCP in the tool list gives the agent the capability to reach your data. It does not, by itself, cause the agent to decide that reaching for the data is the right move for every question. In a workspace with several connected MCPs, or even in a single-MCP workspace, the agent can plausibly decide a question does not call for a tool at all, and default to an answer drawn from training data.
The column on the left in the comparison above is what that failure mode looks like. The agent can see the tool list. It just does not have a signal strong enough to pick up the tool.
The small cue that activates the MCP
The signal the agent needs is small. A question phrased as "How are ACME Corp sales doing?" (identical to the original except for the two-word entity reference) is reliably sufficient. The agent scanning the tool list sees that the Plexara MCP is named and tagged for ACME Corp and treats the entity match as a direct instruction to consult this particular server.
Once the agent decides to engage the MCP, an automatic sequence begins. The platform_info tool carries a description whose opening sentence identifies it as the mandatory first call in every session. A compliant agent reading that description calls platform_info on its own, without being asked.
What platform_info loads into the agent's context
The platform_info response is a structured document describing the specific Plexara deployment the session is connected to. It identifies the deployment by name, carries a tag array that restates the business domains in retrieval-friendly form, advertises the toolkits and feature flags enabled, exposes a library of pre-built prompts, and most substantively, includes an agent_instructions block written as a markdown operating manual addressed directly to the agent.
The agent_instructions block is authored per customer. It is where each organization's data estate, tenant conventions, query patterns, critical rules, and business terminology are encoded for the agent to read at the start of every session. Two Plexara deployments for two different customers share the same platform and the same tools but return very different agent_instructions, because the specifics of every customer's data are different. The platform itself is database-agnostic: it reaches data through Trino and works against any combination of backends Trino supports.
For the public ACME Corp demo, the operating manual describes a national retailer with approximately 500 stores, eight sales regions, roughly 10,000 products, 100,000 customers, and three million sales transactions covering two years. The manual prescribes a mandatory three-step workflow the agent must follow when serving a data question, provides the query patterns the demo uses for common aggregation shapes, and publishes measured benchmarks showing the pushed-down analytics path completes in roughly one second on the three-million-row transactions index where standard SQL against the same index takes more than eighty.
Every Plexara deployment also ships an interactive MCP App at the ui://platform-info resource URI, with mime type text/html;profile=mcp-app. The embed below renders the same ACME Corp demo platform_info payload the agent received when it made the call.
MCP App: platform-info (ACME Corp demo)
The workflow the agent follows next: discover, query, enrich
With platform_info in the context window, the agent proceeds through the three-step workflow the operating manual prescribes. The exact details are customer-specific because agent_instructions is customized per deployment. The shape that follows is the ACME demo's, but the structure generalizes to any customer backend.
The three-step workflow platform_info prescribes
Before writing any query, the agent calls datahub_search on the topic, then datahub_get_queries on the matched dataset to retrieve curated, pre-benchmarked query templates. Jumping straight to a free-form query is an anti-pattern: the curated templates are faster, tested, and annotated with performance characteristics.
The agent reaches data through Trino, regardless of the underlying backend. Each customer's operating manual describes the right query pattern for the data estate at hand (plain SQL, pushed-down OLAP on OpenSearch, or whatever is appropriate). Measured performance benchmarks in the operating manual tell the agent which path to choose.
Plexara attaches semantic enrichment to the query result automatically: descriptions, tags, owners, column detail, glossary terms, PII flags. If the result is large, the agent saves it as an asset rather than letting rows flood the conversation. Follow-up questions recall the saved assets and the enriched metadata from memory.
The user sees none of this machinery directly. What the user sees is a quick, grounded answer with the tables and aggregation methods named in the response. Each step is the subject of its own lesson later in this series.
The cue is only needed once per session
Once platform_info has been invoked, the operating manual sits in the conversation's context window. Subsequent questions in the same session do not require the "ACME Corp" prefix the first question needed. A follow-up such as "How did Q3 compare to Q2?" or "Which region leads on revenue per store?" is now interpreted against the loaded operating manual. The agent already knows the tenant, the relevant catalogs, the required query patterns, and the business meaning of the terms in the question.
The cue is a one-time cost of entry. On the first question you are paying a small price in specificity. On every subsequent question in the session, the full tenant context is inherited for free.
What carries forward, and at which scope
A new conversation starts with an empty context window. If you return the next day and ask "How are sales doing?" without the ACME Corp prefix, the agent may once again default to a generic answer unless the same cue is provided. Within a session the first cue is enough; across sessions the cue resets.
Plexara reduces this recurring cost through two compounding mechanisms: memory that carries per-user knowledge across sessions, and a knowledge capture pipeline that promotes validated observations into organization-wide catalog documentation. Both are covered in depth in 206. The summary below is what to expect.
What carries forward, and at which scope
Within this session
Context behavior from 103platform_info output, the operating manual, and every tool call and result stay in the context window. Follow-up questions no longer need the entity cue.
Example: "How did Q3 compare to Q2?" asked after the first cued question resolves correctly without repeating the tenant name.
Across sessions (Plexara memory)
Covered in 206Personal preferences, prior corrections, and small facts the user or agent saved. A fresh session starts empty of context, but the agent is guided to call memory_recall when prior-session context would help, and can surface relevant memories without the user naming them by hand.
Example: A user who previously said they prefer a fiscal-calendar view of sales has that preference retrieved via memory_recall on a relevant later question, without having to restate it.
Into organizational knowledge (after admin review)
Covered in 206Insights flagged during a session (user corrections, agent-discovered patterns, enrichment gaps) are captured and routed through a four-step review pipeline. Approved insights become catalog documentation, raising answer quality for everyone.
Example: One user clarifies a column definition. After admin review, every future user asking about that column sees the correct definition on the first try.
Every engagement after the first one has more context than the one before it. Your first day sets a lower bound on response quality; every session after it raises that bound.
Built-in prompts help on day one
The platform_info response also exposes a prompts array describing named workflows the deployment supports. The ACME demo ships prompts for exploring the available data on a topic, creating an interactive dashboard, generating a structured markdown report, tracing data lineage for a specific dataset, capturing knowledge from the current conversation, and saving or listing artifacts. Clients that surface MCP prompts to the user can offer these as one-click workflows; clients that do not can still invoke them by name within a prompt. The 208 lesson walks through how these prompts work and how administrators and knowledge curators add more.
Where this leads
Day one resolves into three practical habits: name the tenant on the first question, let platform_info run, and start enjoying the rest of the session as a grounded conversation. The rest of the 200 series walks through each step of the workflow in detail.
Key terms
Five terms cover the vocabulary specific to this lesson. platform_info and the session gate are the two every Plexara user eventually names; discover-query-enrich is the workflow they run inside.
Key Terms
- platform_info
- The mandatory first tool call in every Plexara session. Returns the operating manual for the specific deployment: tenant, toolkits, feature flags, a prompt library, and a customer-specific agent_instructions block. Also defined in 201.
- Session gate
- The server-side enforcement that refuses every tool call in the deployment until platform_info has been invoked. Bypassing the convention is not possible at the client level.
- agent_instructions
- The markdown operating manual authored per customer, embedded in the platform_info response. Encodes tenant conventions, data-estate specifics, mandatory workflows, and benchmarked query patterns the agent should follow.
- Entity cue
- The small prompt pattern on the first question of a session that names the tenant or the subject by its specific term (for example, "ACME Corp sales"), giving the agent an unambiguous signal to consult the Plexara MCP rather than answer from training data.
- Discover-query-enrich
- The three-step workflow platform_info prescribes: call datahub_search and datahub_get_queries to discover the right dataset and curated query; run the query through Trino; enrich the result with catalog metadata and persist it as an asset if needed.
