Day 4: Agent Tools & Best Practices

Connecting AI to Reality

The “Brain in a Jar” Problem

The Isolated Genius

• Imagine the world’s smartest physicist.
• Locked in a soundproof room.
• With no hands.
• And no memory of anything that happened 5 minutes ago.

• This is your LLM.
• It can solve differential equations, but it can’t check the weather.
• It can write code, but it can’t run it.
• To build Agents, we need to solve two problems:
  1. Isolation (No hands/senses).
  2. Amnesia (No memory/continuity).

The Goal

AI App Integration

The Two Missing Links

A brain in a jar

1. Spatial Connection: Touching the world (Files, APIs, Databases).
2. Temporal Connection: Existing across time (Waiting, Remembering).

• Today we cover the standardized solutions to these two problems.
• MCP solves the Spatial problem.
• Long-Running Operations solve the Temporal problem.

Part 1: Spatial Connection (MCP)

The “Integration Tax”

The \(M \times N\) problem.

• Different servers specify different interfaces.
• Clients have to implement their own tools for every interface.

Enter MCP: The “USB-C” for AI

The MCP solution to the \(M \times N\) problem.

• MCP servers define their interfaces once in a standardized way for tool-aware LLMs to use.
• MCP clients can then use these servers as tools without having to implement the interface themselves.

• Think of MCP like USB-C.
• You don’t need a different keyboard for a Dell vs. a Mac.
• Similarly, with MCP, you write a “GitHub Tool” once, and it works with Claude, Gemini, and Local Llama.

How it Works: The Invisible Wire

The Invisible Wire

1. Host: The App (e.g., Cursor, Python Script).
2. Client: The “Driver” that speaks MCP.
3. Server: The “App” that has the data (e.g., GitHub, Postgres).

• You don’t see the Client. It’s the invisible wire.
• You just pick a Server (like installing a printer driver) and suddenly your Agent has new capabilities.

Restaurant Analogy

The Restaurant Analogy

Here is how the restaurant analogy in the image explains these concepts:

1. Host (The Maitre d’): This represents the main application or environment (such as Claude Desktop or an IDE) where the user interacts with the AI. It oversees the entire process and manages which “waiters” are available.

2. Client (The Waiters): This is the specific connector within the Host application that maintains a persistent 1:1 connection with a server. Like a waiter, it carries the user’s request to the kitchen and brings the results back.

3. MCP Server (The Chef Bot Station): A small program that exposes specific data or capabilities. It acts as the “chef” that has the actual access to the ingredients (data) and tools needed to fulfill a request.

The Capabilities

The right side of the image illustrates the three primary types of content a server provides:

1. Resources (The Ingredients): These are data sources that the LLM can “read” but not execute. In a technical sense, these are files, database records, or API responses.

2. Tools (The Utensils): These are functions that the model can “call” to perform actions. Just as a chef uses a whisk to change the state of ingredients, a tool allows the model to write code, search the web, or trigger external API actions.

3. Prompts (The Cookbooks): These are pre-defined templates or instructions that help the LLM perform specific tasks consistently, similar to how a recipe ensures a dish is prepared the same way every time.

Part 2: Temporal Connection (LRO)

The “Goldfish Memory” Problem

The “Goldfish Memory” Problem

• This is the “Statefulness Gap”.
• Real business processes take time.
• A manager might take 3 hours to approve an expense.
• If your Python script crashes or the connection drops, the context is lost.

Long-Running Operations (LRO)

LRO Pattern

1. Invoke: Start the task.
2. Pause: Wait for external input (Human-in-the-Loop).
3. Resume: Continue exactly where you left off.

• We need an architecture that supports “Freezing” the agent.
• Think of a waiter taking an order to the kitchen.
• They don’t stand there for 20 minutes. They go do other things.
• When the bell rings (Event), they pick up the plate (Resume).

The Solution: Resumability

• The App Wrapper: A container that saves state to a database.
• The Invocation ID: The unique “Ticket Number” for that specific task.

• In the lab, we saw check_for_approval().
• It looks for a special event: adk_request_confirmation.
• When it sees it, it saves the Invocation ID.
• To resume, we don’t start over. We call run_async(invocation_id=...).
• The Agent wakes up: “Ah, yes, the deployment. Proceeding.”

Visualizing the Loop

A circular workflow diagram. Arrow 1: Agent pauses. Arrow 2: State saved to DB. Arrow 3: Human clicks Approve. Arrow 4: Agent wakes up and finishes task.

• The Agent doesn’t “wait” in active memory.
• It “persists” to disk.
• This creates Safe, Asynchronous Autonomy.

• This allows agents to run for days or weeks.
• It enables Human-in-the-Loop for high-stakes decisions (money, production data).

Summary

The Complete Agent

• LLM: Think & Use Tools
• Spatial Connection:
  • MCP Host: The application that the agent is running in.
  • MCP Client: The agent that is using the MCP tools.
  • MCP Server: The server that is providing the MCP tools.
• Temporal Connection:
  • HIL (Human-in-the-Loop): Pause & Resume
  • LRO (Long-Running Operations): Continue where it left off.

• Without these, you just have a chatbot.
• With them, you have an Agent that can work in the world and across time.