mcp powered agents update

Author: shikhar-cyber

examples/partners/mcp_powered_voice_agents/mcp_powered_agents_cookbook.ipynb

@@ -13,8 +13,17 @@
         "\n",
         "Model Context Protocol (MCP) has quickly become the open standard for building Agentic systems. The protocol provides easy integration of common tool services and the interoperability between models across the AI ecosystem.\n",
         "\n",
+        "### What is MCP?\n",
+        "Model Context Protocol (MCP) is an open protocol designed to standardize how AI models - especially large language models (LLMs) - interface with external tools, data sources, and context providers in a secure, modular, and composable way. MCP provides a unified framework for sending structured requests from an agent or application to a set of “tool services,” such as databases, APIs, or custom logic modules. By adopting MCP, developers can,\n",
+        "* Decouple agent logic from tool implementations: Agents can call out to tools (like a database or search service) using a standard protocol, rather than relying on hardcoded integrations.\n",
+        "* Enforce consistent security and governance: MCP defines authentication, authorization, and data boundary controls between the model and external resources.\n",
+        "* Support modular, reusable agent architectures: Tools can be swapped, updated, or extended without changing the agent code, making it easy to evolve complex workflows.\n",
+        "* Run tools locally or remotely: The same protocol works whether a tool is running in the customer’s environment or in the cloud, supporting privacy and data residency requirements.\n",
+        "\n",
+        "MCP acts as the “middleware” that bridges AI models and the external world, enabling secure, flexible, and maintainable integration of real-world context and capabilities into conversational or autonomous agents.\n",
+        "\n",
         "### Agents in the enterprise\n",
-        "A common pattern seen across the enterprise landscape is to develop agents that are backed by knowledge bases (both structured and unstructured). These bots are divided into:\n",
+        "In today’s enterprise landscape, conversational agents - especially voice-powered ones—are quickly becoming a standard for customer support, internal helpdesks, and task automation. Yet, building robust, scalable voice agents is challenging due to fragmented tooling, integration complexity, and the need for reliable orchestration of backend systems. A common pattern seen across the enterprise landscape is to develop agents that are backed by knowledge bases (both structured and unstructured). These bots are divided into several categories:\n",
         " - copilots for internal use, and \n",
         " - customer-facing assistants. \n",
         "The latter of the two use cases, i.e. customer-facing assistants, tends to have a higher requirement for both accuracy, usability and design. Additionally, one common requirement for customer-facing chatbots is the need to add voice as a modality for user interface (i.e. for phone call automation).\n",
@@ -145,7 +154,7 @@
       "source": [
         "### Defining Tool-use Agents through custom MCP services\n",
         "\n",
-        "First, we define a custom MCP service that host the RAG and web search tools. Specifically, we add `@mcp.tool` functions for:\n",
+        "First, we define a custom MCP service that host the RAG and web search tools using the `FastMCP` interface. Specifically, we add `@mcp.tool` functions for:\n",
         "\n",
         "1.   Retrieving information from a RAG service\n",
         "2.   Searching the broader internet for information using OpenAI's `web_search`\n",
@@ -288,7 +297,14 @@
       "source": [
         "As seen above, we also include the RAG indexing as part of this workflow. In real-world applications, this will not be necessary for every run and if you have a large corpus of data, you may put this in a separate process.\n",
         "\n",
-        "In addition to simple RAG retrieval, we add an extra step to summarize the RAG output. This step is not always necessary, though we've found this to provide more succinct responses to the planner. Whether to do this depends on your system and your latency requirements."
+        "In addition to simple RAG retrieval, we add an extra step to summarize the RAG output. This step is not always necessary, though we've found this to provide more succinct responses to the planner. Whether to do this depends on your system and your latency requirements.\n",
+        "\n",
+        "\n",
+        "### Using Pre-defined MCP Servers\n",
+        "\n",
+        "While implementing custom MCPs servers is relatively straightforward, the power of MCP is the ability to use pre-defined servers that others have built and maintain. Using existing implementations enables more rapid development, has a consistent interface with other tools, and makes data integration more seamless. \n",
+        "\n",
+        "For our database lookup tool, we use the prebuilt [SQLite server](https://github.com/modelcontextprotocol/servers-archived/tree/main/src/sqlite) implementation. As you will see below, we can implement this simply with just a comand line prompt and providing it with a `*.db` file with the data."
       ]
     },
     {
@@ -299,7 +315,7 @@
       "source": [
         "### Defining the Planner Agent\n",
         "\n",
-        "With our input now converted to text, we can define how the MCP server will generate meaningful responses. We create an agent that is explicitly instructed to leverage the available server tools when responding to users.\n",
+        "Next, we can define how the MCP server will generate meaningful responses. The planner agent is a key component within MCP’s agent orchestration pipeline. Its primary function is to decompose user requests into actionable steps and decide which tools, APIs, or agents should be called at each stage. Given the input as text, the planner parses and analyzes the request, maintaining context across multiple turns. Based on the conversation state, it invokes MCP tool services by dispatching tool calls via the MCP server’s orchestration layer. The agent then collects intermediate results, synthesizes responses, and guides the conversation toward resolution.\n",
         "\n",
         "A key design consideration is the model selection for the planner. While larger models like `4.1` offer superior reasoning, low end-to-end latency is critical in voice-driven applications. For this reason, we select the `4.1-mini` model, which achieves a strong balance between reasoning ability and response speed."
       ]
@@ -646,9 +662,9 @@
       "source": [
         "### Specifying the MCP tool services\n",
         "\n",
-        "In our `main` function, we can bring up the various tool-use services we're interested in. Earlier, we defined a custom service for RAG and web search that utilizes the `FastMCP` definition, however, the power of MCP is the ability to use pre-defined servers that others have built.\n",
+        "In our `main` function, we can bring up the various tool-use services we're interested in.\n",
         "\n",
-        "For our database lookup tool, we use the prebuilt [SQLite server](https://github.com/modelcontextprotocol/servers/tree/main/src/sqlite) implementation. To use this, we call `MCPServerStdio` with the parameters provided, in this case, the local `database.db` file."
+        "For our custom server for (RAG and web search), we can use the `MCPServerSse` function to start a server (in this case locally). To bring up the standard MCP SQLite service, we call `MCPServerStdio` with simple arguments provided, in this case, the local `database.db` file."
       ]
     },
     {