instruction: Create a Dockerfile for fundamentals
output: ```dockerfile
  from three core components:Models: These are your GPTs, CodeLlamas, Mistrals. They're doing the
  reasoning, writing, and planning. They're the engine behind the intelligence.Agent: This is where the logic lives. Agents take a goal, break it down, and
  figure out how to get it done. They orchestrate everything. They talk to the
  UI, the tools, the model, and the gateway.MCP gateway: This is what links your agents to the outside world, including
  APIs, tools, and services. It provides a standard way for agents to call
  capabilities via the Model Context Protocol (MCP).Docker makes this AI-powered stack simpler, faster, and more secure by unifying
  models, tool gateways, and cloud infrastructure into a developer-friendly
  workflow that uses Docker Compose.
  This guide walks you through the core components of agentic development and
  shows how Docker ties them all together with the following tools:Docker Model Runner lets you run LLMs
  locally with simple command and OpenAI-compatible APIs.Docker MCP Catalog and
  Toolkit helps you discover
  and securely run external tools, like APIs and databases, using the Model
  Context Protocol (MCP).Docker MCP Gateway lets you orchestrate and manage MCP servers.Docker Offload provides a powerful, GPU-accelerated
  environment to run your AI applications with the same Compose-based
  workflow you use locally.Docker Compose is the tool that ties it all
  together, letting you define and run multi-container applications with a
  single file.For this guide, you'll start by running the app in Docker Offload, using the
  same Compose workflow you're already familiar with. Then, if your machine
  hardware supports it, you'll run the same app locally using the same workflow.
  Finally, you'll dig into the Compose file, Dockerfile, and app to see how it all
  works together.PrerequisitesTo follow this guide, you need to:Install Docker Desktop 4.43 or laterEnable Docker Model RunnerJoin Docker Offload BetaStep 1: Clone the sample applicationYou'll use an existing sample application that demonstrates how to connect a
  model to an external tool using Docker's AI features.
  
  $ git clone https://github.com/docker/compose-for-agents.git
  $ cd compose-for-agents/adk/
  Step 2: Run the application with Docker OffloadYou'll start by running the application in Docker Offload, which provides a
  managed environment for running AI workloads. This is ideal if you want to
  leverage cloud resources or if your local machine doesn't meet the hardware
  requirements to run the model locally. Docker Offload includes support for
  GPU-accelerated instances, making it ideal for compute-intensive workloads like
  AI model inference.To run the application with Docker Offload, follow these steps:Sign in to the Docker Desktop Dashboard.In a terminal, start Docker Offload by running the following command:
  
  $ docker offload start
  When prompted, choose the account you want to use for Docker Offload and select
  Yes when prompted Do you need GPU support?.In the adk/ directory of the cloned repository, run the following command
  in a terminal to build and run the application:
  
  $ docker compose up
  The first time you run this command, Docker pulls the model
  ```