How to build an AI Agent and MCP Server (step-by-step)

Key Concepts

• MCP (Model Context Protocol): A standardized communication protocol that allows AI agents to interact with external tools, databases, or APIs.
• Agent-Tool Decoupling: The architectural separation where the agent (the "brain") remains independent of the implementation details of the tools (the "hands").
• Standard Input/Output (stdio): The communication channel used by MCP servers to exchange data with the agent.
• JSON Schema: The format used by tools to describe their arguments, return types, and functionality to the agent at runtime.
• ADK (Agent Development Kit): The framework used to build the agent and manage the integration of MCP servers.

---

1. Understanding the Model Context Protocol (MCP)

MCP acts as a universal translator between an AI agent and external tools. By sitting in the middle, it allows an agent—which is inherently limited to the knowledge of its language model—to perform real-world tasks like querying databases or fetching live data.

Why MCP is powerful:

• Isolation: Tools run in their own processes; if a tool crashes, the agent remains unaffected.
• Interoperability: Tools can be written in any language (Python, Go, Node.js) as long as they adhere to the MCP standard.
• Discoverability: Tools use schemas to describe themselves, allowing agents to understand how to use them dynamically at runtime.
• Scalability: Developers can add, swap, or version tools without modifying the core agent code.

---

2. The MCP Workflow

The interaction follows a specific loop:

1. Handshake: The agent connects to the MCP server and asks, "What tools do you have?"
2. Discovery: The server responds with a list of tools, including their names, required arguments, and return types.
3. Execution: The agent requests a tool call with specific arguments.
4. Response: The tool executes the task and returns the result as a JSON payload.

---

3. Implementation: Connecting a Google Trends Tool

The video demonstrates upgrading a blog-writing agent to include a "Trends" tool that fetches live data from Google Trends.

Step-by-Step Technical Process:

1. Wrapping the Function: A standard Python function is wrapped using the ADK tool decorator. This automatically inspects the function signature and docstring to generate the necessary JSON schema.
2. Creating the MCP Server Object: An MCP server instance is initialized to handle the communication over stdio.
3. Defining Handlers:
   • List Tools: The server maps the ADK function metadata into an MCP-compliant schema so the agent can "see" the tool.
   • Call Tool: The server receives the tool name and arguments from the agent, validates them, executes the Python function asynchronously, and returns the result as a JSON-formatted text content payload.
4. Transport and Handshake: The server is attached to stdin and stdout. The asyncio.run() function starts the process, enabling the agent to discover and invoke the tool.
5. Integration: The trends tool is added to the agent’s tool list in the main configuration file, allowing the agent to fetch real-time data before drafting content.

---

4. Key Arguments and Perspectives

• The "Brain vs. Hands" Analogy: The presenter argues that an agent is merely a "brain" that plans and decides. MCP provides the "hands and eyes," enabling the agent to interact with the real world.
• Efficiency: By using MCP, the agent remains lightweight. It does not need to contain the logic for every tool it uses; it only needs to know how to request data from the protocol.
• Error Handling: The protocol requires that if a tool fails, it returns a JSON error, ensuring the agent can handle failures gracefully without crashing the entire system.

---

5. Synthesis and Conclusion

The integration of an MCP server transforms a static AI agent into a dynamic, context-aware system. By decoupling the agent from its tools, developers can build modular, scalable, and robust AI applications. The ability to ground an agent's output in real-time data—such as Google Trends—demonstrates the practical utility of MCP in moving agents beyond simple text generation into functional, real-world task automation.