{"success":true,"course":{"all_concepts_covered":["MCP tool discovery and execution signals","Local Salesforce MCP setup and validation","Secure token storage and practical guardrails","Salesforce schema literacy (objects, fields, API names)","Relationship queries for cross-object answers","Structured prompt templates for repeatable checks","Pipeline rollups with aggregation and HAVING","Debugging playbooks and execution trace auditing"],"assembly_rationale":"The course is designed to eliminate the two failure modes identified in the pre-test: schema guessing and tool-call avoidance. It first establishes an analysis-grade MCP mental model with observable signals, then implements a Salesforce-local setup. Next it locks down credential handling, teaches schema mapping and cross-object reasoning, and finally builds reliable prompts plus a debugging-and-auditing cadence suitable for daily executive checks.","average_segment_quality":7.034666666666666,"concept_key":"CONCEPT#7568ff3487a856dadd8c595ee79dbebf","considerations":["Some Salesforce query segments use developer tooling vocabulary; pairing with a RevOps partner for the first week can speed adoption without requiring you to become technical.","The selected Salesforce MCP setup segment is shorter and slightly lower clarity than top MCP mechanics segments; consider having an internal admin provide a one-page setup checklist aligned to your chosen AI client."],"course_id":"course_1774624271","created_at":"2026-03-27T15:30:54.424968+00:00","created_by":"David Morris","description":"Connect an MCP-capable AI assistant to live Salesforce data, so your daily leadership checks run from prompts instead of spreadsheet exports. You’ll learn how tool discovery and schema discovery actually work, how to force reliable tool execution, and how to debug when the assistant guesses instead of querying.","embedding_summary":"","estimated_total_duration_minutes":117.0,"final_learning_outcomes":["Explain the MCP handshake: tool discovery, schema exposure, and structured tool calls, and spot when the assistant is guessing versus querying.","Run a local Salesforce-connected MCP server, attach it to an MCP-capable client, and validate the connection using visible tools and a small live query.","Apply exec-friendly credential hygiene: keep tokens out of prompts/logs, use safer storage, and limit exposed tools for least privilege.","Translate daily leadership questions into Salesforce objects, fields, relationships, and rollup patterns that an MCP tool can query.","Use prompt templates that reliably trigger Salesforce tool calls and return structured, comparable outputs day to day.","Troubleshoot failures by classifying the problem (connection/tool visibility vs schema mismatch vs output validation vs query logic) and capturing safe evidence for escalation.","Operate a repeatable daily check workflow using execution traces and plan/approval gates to maintain trust and safety."],"generated_at":"2026-03-27T15:29:47Z","generation_error":null,"generation_progress":100.0,"generation_status":"completed","generation_step":"completed","generation_time_seconds":253.42115259170532,"image_description":"A VP-level sales leader in a modern office sits at a desk with a laptop and an external monitor, leaning forward with focused attention. On the desk are a notebook with hand-drawn boxes and arrows (integration workflow sketch), a small hardware security key, and a printed sheet with a simple table of “daily checks” categories. In the background, a second person (a RevOps or admin partner) stands slightly behind and to the side, pointing at the notebook diagram, suggesting collaboration without making it feel like a developer scene. The environment feels realistic and executive: tidy desk, neutral lighting, glass-walled meeting room vibe. The mood is confident and operational, emphasizing control and clarity. Key visual cues should imply “live CRM data access through an AI tool” without showing readable UI text: blurred dashboards, subtle cables, and the physical security key as a symbol of safe credential handling.","image_url":"https://course-builder-course-thumbnails.s3.us-east-1.amazonaws.com/courses/course_1774624271/thumbnail.png","interleaved_practice":[{"difficulty":"mastery","correct_option_index":3.0,"question":"You ask: “Show me today’s slipped deals and explain why.” The assistant returns a confident narrative, but you do not see any tool approval prompt, tool name, or returned record set. What is the best next move to confirm whether this was a real Salesforce query?","option_explanations":["Incorrect because adding more tools can increase context/tool-choice confusion; it does not create proof of execution and can reduce reliability.","Incorrect because model choice may change writing quality, but it does not guarantee the MCP client executed a Salesforce tool call or returned live records.","Incorrect because schema text can reduce hallucinated field names, but it still does not prove a live tool call occurred or that counts are current.","Correct! Requiring tool name, query/filters, and a cited sample forces an observable tool-call pathway and gives you evidence the answer is grounded in retrieved Salesforce data."],"options":["Enable access to more MCP servers so the assistant has more options and is more likely to call one.","Switch to a different model, because tool calls depend primarily on model intelligence, not the MCP client.","Paste your Salesforce object model into the chat so the model can answer without needing a tool call.","Ask it to re-run the request and require: the MCP tool name used, the query/filters, and a small cited sample of returned records before the summary."],"question_id":"ip_q1_toolcall_proof","related_micro_concepts":["mcp_handshake_discovery_tool_calls","make_prompts_trigger_right_tools"],"discrimination_explanation":"The fastest way to discriminate “tool-backed” vs “guessed” is to force provenance: tool name, parameters, and a cited result set. Changing models (A) doesn’t address whether the client executed a tool. Uploading schema (C) still doesn’t prove live querying. Adding more servers (D) often worsens tool selection by increasing ambiguity."},{"difficulty":"mastery","correct_option_index":0.0,"question":"Your daily check prompt references “Contract_Value__c,” and the assistant claims the field exists and uses it in the analysis. The numbers look suspicious. Which action best validates the field name before you trust any rollups?","option_explanations":["Correct! A describe/metadata step confirms the real API field names for your org, eliminating ‘it guessed the field’ failures and making subsequent tool calls reliable.","Incorrect because using Amount may be valid in some contexts, but it avoids validation and can produce the wrong metric for your defined check.","Incorrect because verbosity does not validate schema; the assistant can still hallucinate a plausible custom field name.","Incorrect because LIMIT reduces rows returned, not the chance of referencing a non-existent or misnamed field."],"options":["Use a schema discovery step (describe/metadata) to list the object’s actual field API names, then update the prompt to match those names.","Replace the field with a similar standard field (Amount), because standard fields are always present.","Ask the assistant to ‘think harder’ and provide a longer explanation, because deeper reasoning reduces schema mistakes.","Ask for the same analysis but with a LIMIT 10, because smaller outputs are always more accurate."],"question_id":"ip_q2_schema_discovery_fix","related_micro_concepts":["mcp_handshake_discovery_tool_calls","map_salesforce_objects_to_questions"],"discrimination_explanation":"Schema discovery is the mechanism that prevents guessing. Longer explanations (A) can still be wrong. LIMIT (B) controls volume, not correctness of field names. Swapping to a different field (D) changes the business meaning and doesn’t validate the original requirement."},{"difficulty":"mastery","correct_option_index":1.0,"question":"You believe the Salesforce MCP server is configured, but your AI client can’t seem to use it. Which evidence is the strongest indicator that the client is truly connected and has completed capability discovery?","option_explanations":["Incorrect because generic object descriptions can come from the model’s prior knowledge and do not prove tool discovery or live access.","Correct! Seeing the Salesforce tool list and an explicit approval request indicates discovery succeeded and the client is preparing to execute a real tool call.","Incorrect because sandbox type affects data/metadata copies, not whether the MCP client can discover and run tools.","Incorrect because prompts cannot force a connection that is not configured or running; discovery is a client-server process, not a magic keyword."],"options":["The assistant can describe Salesforce objects from memory, even with no tool list visible.","You can see a tool list for the Salesforce MCP server in the client, and the assistant requests approval before running a tool.","Your Salesforce org is a Full Copy sandbox, which guarantees integrations will work.","Your prompt includes the phrase “use Salesforce MCP,” which forces the client to connect."],"question_id":"ip_q3_connection_validation_signal","related_micro_concepts":["set_up_salesforce_mcp_locally","mcp_handshake_discovery_tool_calls"],"discrimination_explanation":"Tool visibility plus an approval/tool-execution signal is direct proof of discovery and execution readiness. Sandbox type (B) is unrelated to MCP client connectivity. Memory-based descriptions (C) can be hallucinated. Prompt wording (D) cannot override a missing connection."},{"difficulty":"mastery","correct_option_index":1.0,"question":"A teammate suggests pasting a Salesforce access token into the chat so the assistant can ‘remember it’ for future daily checks. What is the best practice response, and why?","option_explanations":["Incorrect because command-line arguments can be visible to other processes/users and end up in shell history; it is not a safer default than env/file secret handling.","Correct! Using env vars or a referenced secrets file keeps credentials out of prompts and chat logs, reduces accidental sharing, and supports rotation/revocation routines.","Incorrect because chat history and associated logs are a common exposure point; encryption does not eliminate operational leakage risk.","Incorrect because deletion is unreliable operationally (copies, exports, logs), and it still normalizes an unsafe workflow."],"options":["Disagree, and instead hardcode the token into the MCP server command line so it is never written to disk.","Disagree, and store tokens via environment variables or a secrets file referenced by the MCP setup, keeping secrets out of prompts and chat logs.","Agree, because tokens in chat are encrypted by the AI provider and safer than local files.","Agree, but only if you also ask the assistant to delete the message afterwards."],"question_id":"ip_q4_token_exposure_point","related_micro_concepts":["secure_tokens_for_mcp_access","debug_mcp_connectivity_query_errors"],"discrimination_explanation":"Tokens in chat (A/C) create credential sprawl and can leak via logs, history, screenshots, or exports. Hardcoding into the command line (D) can expose secrets in process listings and scripts. Environment/file indirection (B) reduces accidental exposure and supports rotation."},{"difficulty":"mastery","correct_option_index":0.0,"question":"You want a daily ‘accounts at risk’ list that combines (1) open pipeline value, and (2) no recent activity in 14 days. Which approach best matches the course’s recommended pattern for cross-object checks?","option_explanations":["Correct! Roll up first to get stable, comparable metrics, filter with HAVING, then drill down via relationships for evidence—this keeps daily checks actionable and trustworthy.","Incorrect because it reintroduces the spreadsheet workflow you are trying to eliminate and still doesn’t guarantee consistent definitions.","Incorrect because large raw dumps are hard to validate, slow to review, and often unnecessary when rollups can produce decision-ready summaries.","Incorrect because wildcard text matching is useful for specific string searches, but it does not reliably compute pipeline health metrics or activity thresholds."],"options":["Start with a summary-first rollup (GROUP BY / aggregates) for pipeline by Account, filter with HAVING for thresholds, then drill down via relationship queries to sample supporting records.","Run separate prompts for pipeline and activity, and combine the results manually in a spreadsheet to avoid tool errors.","Ask for a single massive record dump of Accounts, Opportunities, and Activities, then let the assistant reason over it without aggregation.","Use a LIKE wildcard query across all text fields to find ‘at risk’ keywords, because it is more flexible than structured metrics."],"question_id":"ip_q5_cross_object_rollup_pattern","related_micro_concepts":["cross_object_pipeline_metrics_rollups","map_salesforce_objects_to_questions","prompt_templates_for_daily_checks"],"discrimination_explanation":"The recommended pattern is summary first, drill down second: compute rollups with GROUP BY and filter with HAVING, then fetch evidence records through relationships. Massive dumps (A) hurt clarity and reliability. Spreadsheet recombination (C) breaks the live-workflow goal. LIKE searches (D) don’t replace metric definitions."},{"difficulty":"mastery","correct_option_index":3.0,"question":"A tool call appears to run, but the client shows an error that looks like an ‘output validation’ failure. The assistant then proceeds with a generic answer. What is the most likely explanation, and what should you capture for escalation?","option_explanations":["Incorrect because permission mapping/inheritance is not the likely cause of an output validation error and is outside the course’s focus.","Incorrect because rate limiting presents differently and is not the core failure described; the key clue is output schema validation rather than request volume.","Incorrect because context window size does not explain a structured output validation error emitted by the MCP tool interface.","Correct! A mismatched output structure can cause a tool to be treated as failed even if it ‘ran.’ Capture tool name, time, and the validation error so the admin/dev can reproduce safely."],"options":["Your Salesforce permissions were inherited incorrectly, so you should capture your role and org chart for IT.","Salesforce API rate limits were exceeded, so you should capture the 429 response and wait an hour.","The model context window was too small, so you should capture the full chat transcript to expand context.","The MCP tool returned a result that didn’t match its declared output schema, so you should capture the tool name, timestamp, and the validation error details from the Inspector/logs."],"question_id":"ip_q6_output_validation_error","related_micro_concepts":["debug_mcp_connectivity_query_errors","make_prompts_trigger_right_tools"],"discrimination_explanation":"Output validation failures are often schema/return-shape mismatches, and the right artifact is the tool name plus the specific validation error from MCP Inspector/logs. Rate limits (A) are a different error class and are explicitly de-scoped. Permissions (C) are also de-scoped. Context windows (D) are not the key signal here; the client is telling you the tool output shape failed."},{"difficulty":"mastery","correct_option_index":3.0,"question":"Your assistant keeps calling a ‘search’ style tool when you want a precise Opportunity rollup query, even though the correct query tool exists. Which intervention is most aligned with how tool selection works in MCP-style systems?","option_explanations":["Incorrect because comparing tools may be informative, but it does not force the system to execute the correct tool with the correct parameters.","Incorrect because tool descriptions are the agent-facing contract; removing them makes selection less reliable, not more.","Incorrect because tool catalog expansion often increases confusion and context bloat, making tool selection less reliable.","Correct! Clear tool contracts plus explicit prompt constraints steer tool selection and argument filling, reducing ‘wrong tool’ calls."],"options":["Ask the assistant to provide a pros-and-cons list of tools, then let it pick whichever it prefers.","Remove tool descriptions from the server so the assistant relies on common sense rather than docstrings.","Add more tools to the MCP server so the assistant has more flexibility to find the right one.","Rewrite your prompt to explicitly name the intended tool and required parameters, and ensure the tool descriptions/docstrings clearly distinguish search vs query use cases."],"question_id":"ip_q7_wrong_tool_called","related_micro_concepts":["make_prompts_trigger_right_tools","mcp_handshake_discovery_tool_calls"],"discrimination_explanation":"Tool choice is driven by tool names/descriptions and prompt specificity. Making the contract clearer and explicitly requesting the right tool (A) increases reliability. Adding tools (B) increases ambiguity. Pros/cons (C) doesn’t enforce execution. Removing descriptions (D) removes the main guidance the model uses to choose tools."},{"difficulty":"mastery","correct_option_index":2.0,"question":"You’re standardizing a daily VP check workflow so results are consistent and safe. Which operating rule best reflects the course’s recommended execution discipline?","option_explanations":["Incorrect because approvals are a primary safety and verification signal; structured prompts alone do not prevent unsafe tool execution.","Incorrect because it encourages the assistant to guess first; tool calls should be the evidence that supports the narrative, not an afterthought.","Correct! A plan-first, read-only-first workflow with execution traces and approvals keeps daily checks consistent, auditable, and safe.","Incorrect because broad access expands risk and makes it harder to interpret what data the assistant used."],"options":["Disable approvals to reduce friction; instead, rely on structured prompts to prevent unsafe actions.","Ask the assistant to generate the final narrative first, then retroactively request the tool calls if something looks wrong.","Require a plan-first step that states the intended tools and outputs, run read-only-first, and keep an execution trace of tool calls for quick review.","Use ‘allow all orgs’ so the assistant can roam freely; you can filter later in the summary."],"question_id":"ip_q8_repeatable_vp_rhythm","related_micro_concepts":["repeatable_vp_check_workflow","secure_tokens_for_mcp_access","mcp_handshake_discovery_tool_calls"],"discrimination_explanation":"Plan-first plus read-only posture plus execution traces create a controllable, auditable workflow (B). Broad org access (A) increases blast radius. Narrative-first (C) encourages guessing. Disabling approvals (D) removes the key safety checkpoint for tool execution."}],"is_public":true,"key_decisions":["Segment 1 [N3vHJcHBS-w_154_484]: Chosen first to directly address the missed pre-test concepts (tool/schema discovery and tool-call execution) without repeating “why MCP” framing.","Segment 2 [RhTiAOGwbYE_2092_2403]: Placed early to give the leader a concrete way to verify tool-use (approval/visible execution) and apply guardrails before connecting Salesforce.","Segment 3 [q0hO2l6aI04_1829_2161]: Added right after governance to clarify what “local vs remote” actually means in runtime terms (stdio vs HTTP), supporting better setup decisions without diving into auth walkthroughs.","Segment 4 [KslkR_11jL8_51_399]: Selected as the most direct Salesforce-specific local MCP setup and validation clip (tools visible, simple query runs), which is the course’s practical bridge from theory to live data.","Segment 5 [e_iNf2jf8Kg_620_1078]: Chosen to teach practical secret handling (env/file indirection) and least-privilege tool exposure, matching the credential-hygiene focus while staying leader-comprehensible.","Segment 6 [q0hO2l6aI04_2162_2624]: Included to cover executive-relevant security risks (credential sprawl, malicious MCP servers, prompt injection pathways) without re-teaching OAuth or privacy basics.","Segment 7 [WtY6zUe5Uok_291_790]: Added to operationalize Salesforce schema discovery (API names, Object Manager workflow) so prompts reference real fields instead of guesses.","Segment 8 [2ioSL0nayqg_420_911]: Placed after schema basics to strengthen “query logic hygiene” (AND/OR, NULL checks), which is a common reason daily checks return empty or misleading results.","Segment 9 [WtY6zUe5Uok_3146_4020]: Selected to teach cross-object relationship paths (child-to-parent and parent-to-child subqueries), enabling pipeline health questions that require joining objects.","Segment 10 [-8k9lGpGQ6g_627_1507]: Included to solve the diagnosed gap “how prompts trigger tool calls” by showing how tool names/docstrings and specificity steer correct tool selection (and why the wrong tool gets called).","Segment 11 [PeLIweOFXTM_83_511]: Chosen to convert one-off prompting into repeatable daily prompt templates with structured outputs, matching the VP’s need for consistent, comparable checks.","Segment 12 [WtY6zUe5Uok_4815_5371]: Added to teach rollup-style thinking (GROUP BY + HAVING) so the assistant can produce leadership-ready summaries before drilling into records.","Segment 13 [cYtegsQTDMw_614_989]: Selected as the core debugging playbook for tool failures using MCP Inspector and output-schema validation, addressing “how to tell when it didn’t actually work.”","Segment 14 [vVdS-ZEFf50_155_481]: Included to make execution observable at an operator level (tool-call traces, inputs/outputs, error branches), supporting repeatable daily operations and trust.","Segment 15 [li788UL1qyI_1064_1377]: Finalized the course with an exec-friendly control loop (plan first, then approve execution), reinforcing safe, repeatable workflows over live Salesforce data."],"micro_concepts":[{"prerequisites":[],"learning_outcomes":["Explain what MCP clients and servers each do in a Salesforce workflow","Describe how tool lists and schema/metadata get exposed to the AI","Recognize when an answer likely came from a real tool call versus model guessing"],"difficulty_level":"beginner","concept_id":"mcp_handshake_discovery_tool_calls","name":"MCP handshake, discovery, and tool calls","description":"Learn the behind-the-scenes sequence: your AI client discovers MCP tools and schemas, selects a tool, sends a structured call, and uses the returned data to answer. This targets the two common failure points: “it guessed instead of calling” and “it doesn’t know my fields.” ([modelcontextprotocol.io](https://modelcontextprotocol.io/specification/2025-11-25/basic?utm_source=openai))","sequence_order":0.0},{"prerequisites":["mcp_handshake_discovery_tool_calls"],"learning_outcomes":["Choose a practical setup path (official Salesforce DX MCP server vs reputable third-party) based on your needs","Confirm the AI client can see the Salesforce MCP tools and successfully retrieves live data","Adopt a safe “read-only-first” operating posture for leadership analytics"],"difficulty_level":"beginner","concept_id":"set_up_salesforce_mcp_locally","name":"Set up Salesforce MCP locally","description":"Set up a local Salesforce-connected MCP server and attach it to an MCP-capable AI client so you can query live CRM data without exporting spreadsheets. You’ll learn how to validate that the connection is real by checking visible tools and running a simple “describe/query then summarize” loop. ([github.com](https://github.com/salesforcecli/mcp))","sequence_order":1.0},{"prerequisites":["set_up_salesforce_mcp_locally"],"learning_outcomes":["Identify the main token exposure points (local files, environment settings, chat logs, debug logs)","Apply a rotation/revocation routine appropriate for an exec workflow","Spot prompt-injection warning signs that could cause unsafe tool execution"],"difficulty_level":"beginner","concept_id":"secure_tokens_for_mcp_access","name":"Secure tokens for MCP access","description":"Learn practical credential hygiene for MCP: where tokens end up, how to store them safely, how to rotate/revoke them, and what not to paste into prompts or logs. You’ll also learn why MCP tool-chains increase the impact of prompt injection and how to apply simple guardrails as a non-technical operator. ([techradar.com](https://www.techradar.com/pro/security/anthropics-official-git-mcp-server-had-some-worrying-security-flaws-this-is-what-happened-next?utm_source=openai))","sequence_order":2.0},{"prerequisites":["set_up_salesforce_mcp_locally","secure_tokens_for_mcp_access"],"learning_outcomes":["Map common leadership checks (stale pipeline, no activity, slipped close dates) to specific objects and fields","Use “describe metadata” outputs to confirm field names and relationship paths","Build a simple “schema map” you can reuse inside prompts to reduce errors"],"difficulty_level":"beginner","concept_id":"map_salesforce_objects_to_questions","name":"Map Salesforce objects to questions","description":"Translate your daily VP questions into the Salesforce objects, fields, and relationships that actually hold the data (including custom objects and “activity” fields). You’ll learn lightweight schema discovery techniques so your prompts reference the right API names and relationships. ([developer.salesforce.com](https://developer.salesforce.com/docs/atlas.en-us.mobile_sdk.meta/mobile_sdk/ref_rest_apis_describe.htm?utm_source=openai))","sequence_order":3.0},{"prerequisites":["mcp_handshake_discovery_tool_calls","map_salesforce_objects_to_questions"],"learning_outcomes":["Write prompts that explicitly require a Salesforce tool call and a cited result set","Iterate when a tool call fails by adjusting constraints instead of rewriting the whole prompt","Detect tool-call avoidance (hallucinated fields, impossible counts, missing query provenance)"],"difficulty_level":"beginner","concept_id":"make_prompts_trigger_right_tools","name":"Make prompts trigger the right tools","description":"Learn how to phrase requests so the AI reliably chooses the correct MCP tool, passes the right parameters, and shows its work with retrieved records. You’ll also learn quick “sanity checks” to detect when the model answered without calling Salesforce at all. ([modelcontextprotocol.io](https://modelcontextprotocol.io/specification/2025-11-25/basic?utm_source=openai))","sequence_order":4.0},{"prerequisites":["make_prompts_trigger_right_tools"],"learning_outcomes":["Create 3–5 standard daily prompts that return the same columns every time","Specify time windows, thresholds, and grouping rules without ambiguity","Add lightweight verification prompts that confirm counts and sampling before you act"],"difficulty_level":"beginner","concept_id":"prompt_templates_for_daily_checks","name":"Prompt templates for daily checks","description":"Design reusable prompt templates for your “preemptive checks” (pipeline hygiene, account coverage, rep follow-through) that produce structured outputs you can act on quickly. You’ll learn how to request consistent tables, thresholds, and exceptions so results are comparable day to day.","sequence_order":5.0},{"prerequisites":["map_salesforce_objects_to_questions","prompt_templates_for_daily_checks"],"learning_outcomes":["Ask for pipeline rollups by rep, stage, and time window using consistent definitions","Combine activity signals with opportunity signals to flag accounts at risk","Choose a “summary first, drill-down second” pattern to keep results decision-ready"],"difficulty_level":"beginner","concept_id":"cross_object_pipeline_metrics_rollups","name":"Cross-object pipeline metrics and rollups","description":"Learn beginner-friendly patterns for cross-object aggregation (Account ↔ Opportunities ↔ Activities) to answer “health” questions that single reports miss. You’ll focus on the concepts behind relationship queries and aggregate summaries like counts and sums, not on becoming a Salesforce developer. ([trailhead.salesforce.com](https://trailhead.salesforce.com/content/learn/modules/soql-for-admins/use-bind-variables-and-aggregate-functions?utm_source=openai))","sequence_order":6.0},{"prerequisites":["set_up_salesforce_mcp_locally","secure_tokens_for_mcp_access","map_salesforce_objects_to_questions","make_prompts_trigger_right_tools"],"learning_outcomes":["Classify failures into connection, authentication-expiry, schema/field mismatch, and query-logic issues","Use a safe “minimum reproduction prompt” to isolate the problem fast","Escalate with the right artifacts (tool list, failing object/field, timestamp) without sharing tokens"],"difficulty_level":"beginner","concept_id":"debug_mcp_connectivity_query_errors","name":"Debug MCP connectivity and query errors","description":"Create a simple troubleshooting playbook for when the AI can’t connect, can’t see fields, or returns query errors. You’ll learn what evidence to capture (without leaking secrets) so a Salesforce admin or RevOps partner can fix issues quickly. ([developer.salesforce.com](https://developer.salesforce.com/docs/platform/einstein-for-devs/guide/devagent-mcpservers.html))","sequence_order":7.0},{"prerequisites":["prompt_templates_for_daily_checks","cross_object_pipeline_metrics_rollups","debug_mcp_connectivity_query_errors"],"learning_outcomes":["Build a daily “exceptions first” review that replaces spreadsheet exports","Define verification rules (when to drill down to records) before acting on AI output","Create a one-page output format that makes rep follow-up unambiguous"],"difficulty_level":"beginner","concept_id":"repeatable_vp_check_workflow","name":"Run a repeatable VP check workflow","description":"Turn your prompts into a repeatable operating rhythm: daily checks, exception-based follow-ups, and a consistent handoff format for reps or RevOps. You’ll set expectations for accuracy (what must be verified) and speed (what can be trusted from a summary).","sequence_order":8.0}],"overall_coherence_score":8.53,"pedagogical_soundness_score":8.6,"prerequisites":["Basic Salesforce objects and reporting vocabulary","Comfort with the idea of API tokens and least-privilege access","High-level understanding of OAuth and Salesforce API limits (no walkthrough needed)","Comfort editing a small config file (JSON) with help if needed"],"rejected_segments_rationale":"Segments primarily teaching skipped topics were excluded: OAuth/authentication walkthroughs, permission mapping/inheritance, privacy/residency deep-dives, API rate limits/context window limits, and high-level “why MCP” overviews. Several MCP ‘intro’ segments were also rejected due to redundancy with the selected MCP mechanics module, and multiple ‘connect MCP to client’ demos were avoided because the Salesforce-specific setup segment already covers the practical verification loop.","segment_thumbnail_urls":["https://i.ytimg.com/vi/N3vHJcHBS-w/maxresdefault.jpg","https://i.ytimg.com/vi/RhTiAOGwbYE/maxresdefault.jpg","https://i.ytimg.com/vi/q0hO2l6aI04/maxresdefault.jpg","https://i.ytimg.com/vi/KslkR_11jL8/maxresdefault.jpg"],"segments":[{"before_you_start":"This course starts by making MCP feel concrete. You will see the behind-the-scenes sequence, from tool discovery to a structured tool call and returned data, so you can recognize when your assistant truly queried Salesforce, versus when it guessed.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/N3vHJcHBS-w_154_484/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["MCP client-server architecture","Capability discovery (tools/resources/prompts)","Responsibilities of the MCP client (discovery, data handling, tool execution)","MCP server primitives: prompt templates, resources, tools","Transport options: stdio vs HTTP/SSE"],"duration_seconds":329.30805882352945,"learning_outcomes":["Explain, in plain language, what the MCP client does versus what the MCP server does","Describe how an AI client discovers available tools/resources and why that matters for reliability","Differentiate prompts vs resources vs tools and choose which category a Salesforce capability should be","Decide when a local (stdio) connection is appropriate versus a networked (HTTP/SSE) MCP deployment"],"micro_concept_id":"mcp_handshake_discovery_tool_calls","prerequisites":["Basic understanding of client/server software (high-level is enough)","Comfort with the idea that an AI app can call external functions/tools"],"quality_score":7.449999999999999,"segment_id":"N3vHJcHBS-w_154_484","sequence_number":1.0,"title":"How MCP Discovery and Tool Calls Work","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"","overall_transition_score":0.0,"to_segment_id":"N3vHJcHBS-w_154_484","pedagogical_progression_score":0.0,"vocabulary_consistency_score":0.0,"knowledge_building_score":0.0,"transition_explanation":"N/A for first segment"},"url":"https://www.youtube.com/watch?v=N3vHJcHBS-w&t=154s","video_duration_seconds":1189.0},{"before_you_start":"Now that you have the MCP flow in mind, you need a practical way to verify it in real life. This segment shows what tool execution looks like in the client, including approvals and visible tool results, so you can trust what you act on.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/RhTiAOGwbYE_2092_2403/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Verifying a server is connected and tools are visible (operational confirmation)","Detecting tool usage: permission/approval prompts and observed tool results","Building a simple MCP client workflow: connect → list tools → call tool → read resource → get prompts (conceptual)","Server-to-client context messages (info/debug/progress) for long-running actions","Roots as a least-privilege mechanism for file-system access (shared folders)","Sampling: server requests LLM help through the client (client controls model/limits)","Elicitation: server asks client to get additional user input (confirmation/clarification loop)","Separation of responsibilities: server defines tools/logic; client owns model configuration and user interaction"],"duration_seconds":311.52099999999973,"learning_outcomes":["Spot the two key signals of real tool execution: (1) the client asks to approve tool use; (2) the response includes tool-derived results","Explain roots as a practical least-privilege control (share only specific folders/files, not the whole machine)","Explain why the client owns model settings (sampling) and how that helps security/control in enterprise setups","Describe elicitation as a built-in ‘ask the user for confirmation/details’ mechanism to prevent wrong actions"],"micro_concept_id":"mcp_handshake_discovery_tool_calls","prerequisites":["Understanding that connecting to real systems requires guardrails (approvals, least privilege)","Comfort with the idea that an assistant may ‘call tools’ behind the scenes"],"quality_score":7.15,"segment_id":"RhTiAOGwbYE_2092_2403","sequence_number":2.0,"title":"Verify Tool Use With Approvals","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"N3vHJcHBS-w_154_484","overall_transition_score":8.85,"to_segment_id":"RhTiAOGwbYE_2092_2403","pedagogical_progression_score":8.5,"vocabulary_consistency_score":9.0,"knowledge_building_score":9.0,"transition_explanation":"Moves from the conceptual discovery/execution model into the observable, leader-usable signals that confirm tool calls happened."},"url":"https://www.youtube.com/watch?v=RhTiAOGwbYE&t=2092s","video_duration_seconds":2414.0},{"before_you_start":"With tool execution signals clear, the next question is where the MCP server actually runs. This segment explains the practical difference between local stdio and remote HTTP setups, so you can reason about reliability, setup effort, and failure points.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/q0hO2l6aI04_1829_2161/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["MCP client–server architecture","Local process servers via stdio (JSON-RPC)","Remote servers via HTTP (streaming/evented)","Tool list fetching and update notifications","Practical reality: running MCP via npx/uvx/docker"],"duration_seconds":332.095,"learning_outcomes":["Describe the minimum moving parts in an MCP setup (client + server + transport)","Choose the right mental model for local MCP vs hosted MCP","Understand what ‘attach an MCP server to an AI client’ actually means operationally"],"micro_concept_id":"mcp_handshake_discovery_tool_calls","prerequisites":["Basic notion of ‘local computer’ vs ‘remote service’","High-level familiarity with ‘client’ and ‘server’ roles"],"quality_score":7.300000000000001,"segment_id":"q0hO2l6aI04_1829_2161","sequence_number":3.0,"title":"Local vs Remote MCP in Practice","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"RhTiAOGwbYE_2092_2403","overall_transition_score":8.3,"to_segment_id":"q0hO2l6aI04_1829_2161","pedagogical_progression_score":8.0,"vocabulary_consistency_score":8.5,"knowledge_building_score":8.5,"transition_explanation":"Extends tool-execution observability into the runtime detail that explains why local setups feel simpler and more dependable than remote ones."},"url":"https://www.youtube.com/watch?v=q0hO2l6aI04&t=1829s","video_duration_seconds":4340.0},{"before_you_start":"You have the MCP mental model, and you know what real tool execution should look like. Now you will connect a Salesforce MCP server locally, confirm the tools show up in your client, and run a small live query to prove it’s working.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/KslkR_11jL8_51_399/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Leader mental model: MCP as a bridge between LLM and Salesforce","Local MCP configuration via mcp.json in a VS Code SFDX project","Tool discovery at a practical level (MCP list servers; seeing Salesforce server present)","Tool execution mechanics: natural-language prompt triggers a specific MCP tool call","How to tell what the assistant actually executed (seeing references/parameters like a query)","Basic live data retrieval example (querying Account records)"],"duration_seconds":347.359,"learning_outcomes":["Explain the practical chain: prompt → MCP tool → Salesforce response","Identify where MCP configuration lives (mcp.json under .vscode) and what it controls at a high level","Verify that a Salesforce MCP server is registered/visible before attempting prompts","Recognize when a prompt resulted in an actual Salesforce query/tool execution by checking tool references/parameters"],"micro_concept_id":"set_up_salesforce_mcp_locally","prerequisites":["Basic familiarity with Salesforce concepts (org, Account object)","Awareness that an AI client can call tools/functions (no need to know implementation details)","High-level comfort with VS Code as a container for setup steps (no coding required)"],"quality_score":6.5249999999999995,"segment_id":"KslkR_11jL8_51_399","sequence_number":4.0,"title":"Connect MCP to Salesforce, Confirm Live Data","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"q0hO2l6aI04_1829_2161","overall_transition_score":8.95,"to_segment_id":"KslkR_11jL8_51_399","pedagogical_progression_score":8.5,"vocabulary_consistency_score":8.5,"knowledge_building_score":9.5,"transition_explanation":"Turns the local-vs-remote concept into a concrete local setup path, using Salesforce as the real system of record."},"url":"https://www.youtube.com/watch?v=KslkR_11jL8&t=51s","video_duration_seconds":753.0},{"before_you_start":"Before you scale this beyond experimentation, you need safe defaults. This segment shows where tokens can accidentally leak, and how to store secrets using environment or file references, plus how to limit the exposed tool surface for least privilege.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/e_iNf2jf8Kg_620_1078/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Secure credential handling via env/file indirection","Token persistence/refresh as an operational concern","Caching, sessions/daemon for repeated tool calls","Tool surface restriction via include/exclude filters (least privilege)","Local setup workflow: install → connect → list/help → call","AI-agent integration via a “skill” that teaches discovery workflow","Troubleshooting mental model: discovery adds turns; savings accrue later","Why MCP alone doesn’t prevent schema/context bloat"],"duration_seconds":458.4200810810811,"learning_outcomes":["Set practical safety requirements for a Salesforce-connected MCP setup (no secrets on CLI; env/file-based secret sourcing; token rotation expectations)","Specify least-privilege expectations (whitelist tools; restrict to read-only/reporting endpoints where possible)","Use a simple mental checklist to debug ‘why didn’t the AI run the query?’ by verifying the list/help/discovery steps happened and recognizing the initial discovery-turn overhead","Explain to your team why ‘we use MCP’ is not the same as ‘we solved schema/context bloat’"],"micro_concept_id":"secure_tokens_for_mcp_access","prerequisites":["Comfort with the idea of storing credentials securely (even if not configuring OAuth step-by-step)","Basic understanding that tools can be restricted for safety"],"quality_score":7.41,"segment_id":"e_iNf2jf8Kg_620_1078","sequence_number":5.0,"title":"Store Tokens Safely, Reduce Exposure","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"KslkR_11jL8_51_399","overall_transition_score":8.75,"to_segment_id":"e_iNf2jf8Kg_620_1078","pedagogical_progression_score":8.5,"vocabulary_consistency_score":8.5,"knowledge_building_score":9.0,"transition_explanation":"After proving live Salesforce access works, it adds the operational discipline needed to keep credentials out of prompts, logs, and unsafe configurations."},"url":"https://www.youtube.com/watch?v=e_iNf2jf8Kg&t=620s","video_duration_seconds":1164.0},{"before_you_start":"Now that you know how to store tokens safely, you need to understand the biggest ways teams still get burned. This segment covers risks from untrusted MCP servers, accidental exposure, and prompt-injection pathways, plus practical guardrails you can apply quickly.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/q0hO2l6aI04_2162_2624/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Supply-chain risk from running untrusted MCP code","Secret/credential exposure when testing multiple MCP servers","Shadow IT via locally installed MCP servers","Common insecure defaults (listening on network interfaces, no auth)","Prompt injection via tool-returned content","Practical guardrails: scanning, allowlists, enforcement"],"duration_seconds":462.2340000000004,"learning_outcomes":["Identify the main ways MCP setups leak or spread credentials","Recognize red flags in MCP servers (untrusted source, insecure defaults, broad permissions)","Describe a pragmatic guardrail strategy (visibility → scanning → allowlist/enforcement)"],"micro_concept_id":"secure_tokens_for_mcp_access","prerequisites":["Basic understanding of ‘credentials/tokens’","Awareness that installing software can introduce risk"],"quality_score":7.625,"segment_id":"q0hO2l6aI04_2162_2624","sequence_number":6.0,"title":"Avoid Credential Sprawl and Unsafe MCPs","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"e_iNf2jf8Kg_620_1078","overall_transition_score":8.45,"to_segment_id":"q0hO2l6aI04_2162_2624","pedagogical_progression_score":8.0,"vocabulary_consistency_score":8.5,"knowledge_building_score":9.0,"transition_explanation":"Builds from safe storage tactics into the broader threat model and governance risks that appear once multiple servers and tokens are in play."},"url":"https://www.youtube.com/watch?v=q0hO2l6aI04&t=2162s","video_duration_seconds":4340.0},{"before_you_start":"Security and access are set, so the next failure point is schema. This segment shows how to find the exact object and field API names in your org, including custom fields, so your prompts and queries stop failing due to naming mismatch.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/WtY6zUe5Uok_291_790/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["SOQL basic structure: SELECT ... FROM ...","Using Developer Console Query Editor to test queries","Schema discovery via Object Manager","Object API names vs display labels","Field API names and custom field/object suffix __c"],"duration_seconds":499.79999999999995,"learning_outcomes":["Explain what a SOQL query returns (fields from records on an object)","Locate an object’s API name and a field’s API name in Object Manager","Recognize custom objects/fields by the __c suffix and use their API names correctly","Draft and test a simple SOQL query in the Query Editor"],"micro_concept_id":"map_salesforce_objects_to_questions","prerequisites":["Basic familiarity with Salesforce objects (e.g., Account, Contact)","Ability to navigate Salesforce Setup (at a high level)"],"quality_score":7.075000000000001,"segment_id":"WtY6zUe5Uok_291_790","sequence_number":7.0,"title":"Find the Right Objects and Fields","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"q0hO2l6aI04_2162_2624","overall_transition_score":8.55,"to_segment_id":"WtY6zUe5Uok_291_790","pedagogical_progression_score":8.5,"vocabulary_consistency_score":8.0,"knowledge_building_score":9.0,"transition_explanation":"Shifts from secure connectivity to making the data model legible, which is required before prompts can reliably reference fields and relationships."},"url":"https://www.youtube.com/watch?v=WtY6zUe5Uok&t=291s","video_duration_seconds":10666.0},{"before_you_start":"Once you can name fields correctly, the next problem is query logic. This segment shows how AND and OR change results, and how NULL checks catch missing data, so your daily prompts don’t quietly miss key accounts or opportunities.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/2ioSL0nayqg_420_911/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Logical operators AND vs OR in WHERE clauses","Combining multiple conditions","Interpreting result changes when conditions change","Filtering for missing data with = null","Filtering for present data with != null"],"duration_seconds":490.97999999999996,"learning_outcomes":["Decide when to use AND vs OR for multi-condition filters","Debug unexpected query results by changing one condition at a time and observing the impact","Identify records with missing key fields using = null","Exclude incomplete records using != null to produce cleaner outputs for downstream analysis"],"micro_concept_id":"map_salesforce_objects_to_questions","prerequisites":["Comfort with basic SELECT/FROM/WHERE structure","Understanding that some Salesforce fields may be blank (missing data)"],"quality_score":6.460000000000001,"segment_id":"2ioSL0nayqg_420_911","sequence_number":8.0,"title":"Make Filters Precise: AND, OR, NULL","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"WtY6zUe5Uok_291_790","overall_transition_score":8.48,"to_segment_id":"2ioSL0nayqg_420_911","pedagogical_progression_score":8.5,"vocabulary_consistency_score":8.5,"knowledge_building_score":8.5,"transition_explanation":"Builds on schema naming by adding the logic patterns that determine whether your queries return the intended record set."},"url":"https://www.youtube.com/watch?v=2ioSL0nayqg&t=420s","video_duration_seconds":2422.0},{"before_you_start":"Your checks are now correctly filtered at a single-object level. To answer real pipeline health questions, you need relationships. This segment teaches how to traverse parent and child relationships, so summaries can drill into the exact records behind the result.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/WtY6zUe5Uok_3146_4020/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Relationship model via lookup/master-detail fields","Child-to-parent traversal using dot notation (e.g., Account.Name from Contact)","Custom lookup traversal using __r (custom relationship names)","Parent-to-child subquery pattern (subselect in parentheses)","Finding the correct child relationship name for subqueries"],"duration_seconds":874.0190000000002,"learning_outcomes":["Explain, at a high level, how Salesforce objects relate via lookup/master-detail fields","Write (or recognize) a child-to-parent relationship query using dot notation","Convert a custom lookup field name from __c to __r when traversing to the parent record","Write (or recognize) a parent-to-child subquery using the Child Relationship Name","Identify where to find the Child Relationship Name needed for subqueries"],"micro_concept_id":"map_salesforce_objects_to_questions","prerequisites":["Understanding that Salesforce objects are like tables and fields are like columns","Ability to locate fields in Object Manager (helpful but not required)"],"quality_score":7.549999999999999,"segment_id":"WtY6zUe5Uok_3146_4020","sequence_number":9.0,"title":"Query Salesforce Relationships Across Objects","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"2ioSL0nayqg_420_911","overall_transition_score":8.4,"to_segment_id":"WtY6zUe5Uok_3146_4020","pedagogical_progression_score":8.0,"vocabulary_consistency_score":8.0,"knowledge_building_score":9.0,"transition_explanation":"Moves from single-object filtering into cross-object reasoning, which is essential for pipeline health checks that combine Accounts, Opportunities, and related activity signals."},"url":"https://www.youtube.com/watch?v=WtY6zUe5Uok&t=3146s","video_duration_seconds":10666.0},{"before_you_start":"You now know what to query, and how objects relate. The next step is getting the assistant to actually use the MCP tools, not improvise. This segment shows how tool descriptions and prompt specificity determine whether a real tool call happens.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/-8k9lGpGQ6g_627_1507/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Mental model: resources vs tools vs prompts in MCP","How AI decides which MCP tool to call (tool discovery via names + docstrings)","Why docstrings are the agent-facing contract for tool behavior","Tool parameter typing as part of the callable interface","Basic debugging when tools act unexpectedly (wrong tool invoked; need specificity)","Practical testing loop in Claude: expose tools → restart client → verify tools listed → run tools/resources/prompts","File-path/environment gotcha: server runs from client context, so relative paths may not land where you expect"],"duration_seconds":880.1170000000001,"learning_outcomes":["Differentiate when to expose Salesforce data as an MCP resource (read-only context) vs. a tool (query/action) vs. a prompt (standard analysis template)","Explain how the assistant ‘discovers’ tools and why docstrings materially affect whether the correct tool gets called","Recognize common failure modes: tool not discovered, tool called with wrong intent, or unexpected side effects—and identify where to look first","Adopt a simple test workflow: restart client to reload server changes, then validate tool lists and run logs before trusting results"],"micro_concept_id":"make_prompts_trigger_right_tools","prerequisites":["High-level understanding that an AI can call functions/tools","Very light familiarity with code concepts (function inputs/outputs); you do not need to be able to write Python to grasp the MCP mechanics"],"quality_score":7.3999999999999995,"segment_id":"-8k9lGpGQ6g_627_1507","sequence_number":10.0,"title":"Force the Assistant to Call Tools","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"WtY6zUe5Uok_3146_4020","overall_transition_score":8.5,"to_segment_id":"-8k9lGpGQ6g_627_1507","pedagogical_progression_score":8.0,"vocabulary_consistency_score":8.5,"knowledge_building_score":9.0,"transition_explanation":"Transitions from ‘what data to pull’ into ‘how the assistant chooses and executes the right MCP tool’ so prompts reliably become tool calls."},"url":"https://www.youtube.com/watch?v=-8k9lGpGQ6g&t=627s","video_duration_seconds":1560.0},{"before_you_start":"Once tool calls are reliable, your next bottleneck is consistency. This segment shows how to specify structured outputs and reusable templates, so your daily checks return the same fields and format, even when the underlying data changes.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/PeLIweOFXTM_83_511/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Structured prompt components (role, parameters, constraints)","Repeatable workflows using ChatGPT Projects and Custom GPTs","Using exemplars (few-shot examples) to stabilize output quality","Prompt templating via a prompt-generator tool (e.g., Prompt Cowboy)","Specifying Salesforce-relevant outputs (e.g., Opportunity notes; BANT/MEDDIC summaries)"],"duration_seconds":428.26258974358973,"learning_outcomes":["Diagnose when poor AI output is a prompt-structure problem (not a data/model problem)","Draft a structured prompt that specifies role, task, output format, and constraints","Create a dedicated AI workspace (Project/Custom GPT) for a repeatable sales workflow","Use few-shot examples inside instructions to reduce variability and rework","Specify Salesforce-ready outputs (e.g., fields/sections for Opportunity notes including BANT/MEDDIC) that are easier to paste into CRM"],"micro_concept_id":"prompt_templates_for_daily_checks","prerequisites":["Basic familiarity with ChatGPT (starting chats, pasting/uploading text)","Comfort with common sales artifacts (discovery call transcripts, follow-up emails)","Basic familiarity with Salesforce objects like Opportunities and note-taking conventions","Awareness of BANT and/or MEDDIC qualification frameworks"],"quality_score":6.0,"segment_id":"PeLIweOFXTM_83_511","sequence_number":11.0,"title":"Write Daily Check Prompts With Structure","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"-8k9lGpGQ6g_627_1507","overall_transition_score":8.43,"to_segment_id":"PeLIweOFXTM_83_511","pedagogical_progression_score":8.5,"vocabulary_consistency_score":8.0,"knowledge_building_score":8.5,"transition_explanation":"Shifts from tool-selection reliability to output consistency, turning correct tool calls into decision-ready, repeatable reporting formats."},"url":"https://www.youtube.com/watch?v=PeLIweOFXTM&t=83s","video_duration_seconds":536.0},{"before_you_start":"With templates in place, you can now ask for true rollups instead of long record lists. This segment teaches how to summarize with GROUP BY and filter results with HAVING, so you can produce leader-friendly pipeline and coverage metrics quickly.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/WtY6zUe5Uok_4815_5371/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Aggregate functions (COUNT, SUM, AVG, MIN, MAX)","GROUP BY for rollup-style summaries","HAVING to filter aggregated results"],"duration_seconds":556.5,"learning_outcomes":["Choose the appropriate aggregate function for a summary question (count/sum/avg/min/max)","Construct a GROUP BY query to create category-level rollups","Use HAVING to keep only groups that meet a threshold (e.g., top segments only)"],"micro_concept_id":"cross_object_pipeline_metrics_rollups","prerequisites":["Basic SOQL structure (SELECT/FROM/WHERE)","Comfort with the idea of numeric fields (e.g., revenue) and categories (e.g., type)"],"quality_score":7.5,"segment_id":"WtY6zUe5Uok_4815_5371","sequence_number":12.0,"title":"Create Rollups With GROUP BY and HAVING","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"PeLIweOFXTM_83_511","overall_transition_score":8.4,"to_segment_id":"WtY6zUe5Uok_4815_5371","pedagogical_progression_score":8.0,"vocabulary_consistency_score":8.0,"knowledge_building_score":9.0,"transition_explanation":"Builds from structured outputs into the query patterns that generate compact rollups, which are easier to review daily than raw record dumps."},"url":"https://www.youtube.com/watch?v=WtY6zUe5Uok&t=4815s","video_duration_seconds":10666.0},{"before_you_start":"Even great prompts will sometimes fail because the tool call or the returned output is invalid. This segment gives you a clean debugging method using MCP Inspector and output validation clues, so you can isolate the failure quickly and escalate with the right artifacts.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/cYtegsQTDMw_614_989/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Adding error-level MCP logs with structured ‘extra’ metadata","Using the MCP Inspector to observe notifications/log events","Output schema validation as a tool-call failure mode","Why tools must return structured outputs (e.g., dict/object)","Difference between MCP client-visible logs and server console logs","When to use FastMCP’s logging utility for console output"],"duration_seconds":375.3425,"learning_outcomes":["Identify ‘output schema mismatch’ as a reason an MCP tool call can fail even if the server executed code","Use the MCP Inspector conceptually as a source of truth for whether the tool was called and what it returned/logged","Explain why structured outputs (object/dictionary) are important for reliable automation and downstream prompting","Distinguish between (a) logs meant to be shown to the user in the AI client and (b) logs meant for server-side troubleshooting","Describe a leader-friendly debugging checklist: Did the tool call happen? Did it return valid structured data? Did we get progress/log notifications?"],"micro_concept_id":"debug_mcp_connectivity_query_errors","prerequisites":["Basic idea that MCP tools have inputs and outputs","Awareness that tools can have an expected output structure/schema","Comfort with the concept of ‘debugging by inspecting messages’ (no coding required to grasp the idea)"],"quality_score":6.875,"segment_id":"cYtegsQTDMw_614_989","sequence_number":13.0,"title":"Debug Failures With MCP Inspector Evidence","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"WtY6zUe5Uok_4815_5371","overall_transition_score":8.7,"to_segment_id":"cYtegsQTDMw_614_989","pedagogical_progression_score":8.5,"vocabulary_consistency_score":8.5,"knowledge_building_score":9.0,"transition_explanation":"After learning rollups, it adds a troubleshooting layer so you can trust summaries by diagnosing tool-call and output-format failures when they occur."},"url":"https://www.youtube.com/watch?v=cYtegsQTDMw&t=614s","video_duration_seconds":1345.0},{"before_you_start":"Debugging isn’t only about fixing once, it’s about building trust every day. This segment shows how to capture an execution trace of tool calls and errors, so you can verify that key checks were actually run, not just described in text.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/vVdS-ZEFf50_155_481/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Intermediate steps as an agent execution trace","Tool-call observability (what tools ran, with what inputs/outputs)","Token and cost attribution per run","Success vs error branching for reliable logging","Parsing/cleaning structured logs before storing","Operational logging to an external system (Google Sheets)"],"duration_seconds":326.48,"learning_outcomes":["Explain what “intermediate steps” represent and why they are the best evidence of tool execution","Identify which tools an agent called, with what arguments, and what responses came back","Set up success/error routing so both successful and failed runs are logged consistently","Describe a logging schema for each run: timestamp, workflow name, input, output, actions, tokens, total cost","Recognize why cost math should be done in code (deterministic) rather than by the LLM"],"micro_concept_id":"repeatable_vp_check_workflow","prerequisites":["Basic understanding of what an AI agent is and what a “tool call” means","Comfort navigating a no-code workflow tool UI (n8n-like)","Basic familiarity with JSON as structured data (read-only)"],"quality_score":6.5,"segment_id":"vVdS-ZEFf50_155_481","sequence_number":14.0,"title":"Audit Tool Calls With Execution Traces","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"cYtegsQTDMw_614_989","overall_transition_score":8.38,"to_segment_id":"vVdS-ZEFf50_155_481","pedagogical_progression_score":8.5,"vocabulary_consistency_score":8.0,"knowledge_building_score":8.5,"transition_explanation":"Extends debugging from one-off inspection to ongoing observability, so daily checks can be trusted and reviewed consistently."},"url":"https://www.youtube.com/watch?v=vVdS-ZEFf50&t=155s","video_duration_seconds":594.0},{"before_you_start":"You now have the mechanics, the prompts, and the debugging signals. This final segment turns that into an operating habit: insist on a clear plan before execution, then approve tool use step by step, so your workflow stays safe and repeatable.","before_you_start_audio_url":"https://course-builder-course-assets.s3.us-east-1.amazonaws.com/audio/courses/course_1774624271/segments/li788UL1qyI_1064_1377/before-you-start.mp3","before_you_start_avatar_video_url":"","concepts_taught":["Plan mode as an execution-control layer","Separation of planning vs execution/building","Human-in-the-loop approval gates to reduce unwanted changes","Using follow-up questions to clarify agent intent"],"duration_seconds":313.0605714285714,"learning_outcomes":["Explain the difference between an AI’s plan and its execution","Use plan mode to force explicit steps before tool/server actions","Identify when to ask clarifying questions to prevent wrong actions","Adopt a review-then-build workflow to increase reliability"],"micro_concept_id":"repeatable_vp_check_workflow","prerequisites":["Basic familiarity with using an AI assistant interface (chat/agent)","Comfort approving or rejecting suggested steps"],"quality_score":6.7,"segment_id":"li788UL1qyI_1064_1377","sequence_number":15.0,"title":"Use Plan Mode for Safer Execution","transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"vVdS-ZEFf50_155_481","overall_transition_score":8.5,"to_segment_id":"li788UL1qyI_1064_1377","pedagogical_progression_score":8.5,"vocabulary_consistency_score":8.5,"knowledge_building_score":8.5,"transition_explanation":"Turns raw observability into a disciplined operating rhythm: plan first, approve execution, and keep daily checks safe on live Salesforce systems."},"url":"https://www.youtube.com/watch?v=li788UL1qyI&t=1064s","video_duration_seconds":2029.0}],"selection_strategy":"Start at the learner’s ZPD (analysis-level MCP mechanics) to fix the two diagnosed gaps: schema discovery and prompt→tool execution. Then move into a Salesforce-specific local MCP setup, followed by credential hygiene and security guardrails. Next, build Salesforce schema mapping skills (objects, fields, relationships, rollups) so prompts can be grounded. Finish with prompt patterns, debugging playbooks, and a repeatable VP check rhythm with observable tool traces.","strengths":["Directly remediates the two diagnosed gaps (schema discovery and prompt→tool execution) without spending time on skipped basics.","Balances leader-friendly mental models with practical validation steps and debugging evidence you can hand to RevOps/Admin.","Uses a summary-first, drill-down-second reporting approach to keep daily outputs decision-ready."],"target_difficulty":"beginner","title":"Live Salesforce Checks With MCP","tradeoffs":[],"updated_at":"2026-03-27T16:29:09.868629+00:00","user_id":"google_105466341123001344791"}}