You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
[Finch](https://runfinch.com) is an open-source container development tool from AWS. It offers a simple, Docker-compatible CLI powered by containerd and nerdctl. Designed for Linux, macOS, and Windows, Finch is especially useful on Arm-based systems for efficient container workflows.
26
+
27
+
This guide explains how to install Finch on Arm Linux distributions, specifically Amazon Linux 2023 and Ubuntu 24.04.
28
+
29
+
To get started, make sure you're using a system running Arm Linux. You can use a physical Arm device, a cloud instance from AWS, Azure, GCP, or OCI, or an Arm-based virtual machine.
30
+
31
+
To confirm the architecture, run:
32
+
33
+
```bash
34
+
uname -m
35
+
```
36
+
37
+
The output should be `aarch64` for 64-bit Arm systems.
38
+
39
+
## How do I install Finch on Amazon Linux 2023 for Arm?
40
+
41
+
Finch is available as an RPM package in the standard Amazon Linux 2023 repositories, making installation simple.
The `finch` command is now available in your PATH. You can now skip to the section on [verifying the Finch installation](#how-do-i-verify-the-finch-installation).
78
+
79
+
80
+
## How do I install Finch on Ubuntu 24.04 for Arm?
81
+
82
+
Finch doesn't currently provide a Debian package for Ubuntu, but you can install it manually, using the three steps outlined below.
83
+
84
+
### Step 1: Install Finch dependencies
85
+
86
+
Install Nerdctl by following the instructions in the [Nerdctl install guide](/install-guides/nerdctl/). Then install the required tools:
87
+
88
+
```console
89
+
sudo apt install -y \
90
+
golang \
91
+
make \
92
+
build-essential
93
+
```
94
+
95
+
### Step 2: Build and install Finch
96
+
97
+
Clone the Finch repository and build the binary:
98
+
99
+
```console
100
+
git clone https://github.com/runfinch/finch.git
101
+
cd finch
102
+
git submodule update --init --recursive
103
+
make
104
+
sudo make install
105
+
```
106
+
107
+
### Step 3: Configure Finch
108
+
109
+
Create the Finch configuration directories:
110
+
111
+
```bash
112
+
sudo mkdir -p /etc/finch
113
+
sudo mkdir -p /usr/libexec/finch
114
+
```
115
+
116
+
Create the Finch configuration file:
117
+
118
+
```bash
119
+
cat <<EOF | sudo tee /etc/finch/finch.yaml > /dev/null
120
+
# cpus: the amount of vCPU to dedicate to the virtual machine. (required)
121
+
cpus: 2
122
+
123
+
# memory: the amount of memory to dedicate to the virtual machine. (required)
124
+
memory: 2GiB
125
+
126
+
# snapshotters: the snapshotters a user wants to use (the first snapshotter will be set as the default snapshotter)
127
+
snapshotters:
128
+
- overlayfs
129
+
130
+
# dockercompat: a configuration parameter to activate finch functionality to accept Docker-like commands and arguments.
Copy file name to clipboardExpand all lines: content/learning-paths/cross-platform/mcp-ai-agent/_index.md
+12-15Lines changed: 12 additions & 15 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -1,35 +1,32 @@
1
1
---
2
-
title: Deploy an MCP server on a Raspberry Pi 5 and interact with it using an AI agent
2
+
title: Deploy an MCP Server on Raspberry Pi 5 for AI Agent Interaction using OpenAI SDK
3
3
4
-
draft: true
5
-
cascade:
6
-
draft: true
7
-
8
4
minutes_to_complete: 30
9
5
10
-
who_is_this_for: This Learning Path targets LLM and IoT developers who are familiar with Large Language Model (LLM) concepts and networking. You will learn how to deploy a lightweight Model Context Protocol (MCP) server on a Raspberry Pi 5 and interact with it via the OpenAI-Agent SDK.
6
+
who_is_this_for: This Learning Path is for LLM and IoT developers who want to run and interact with AI agents on edge devices like the Raspberry Pi 5. You'll learn how to deploy a lightweight Model Context Protocol (MCP) server and use the OpenAI Agent SDK to create and register tools for intelligent local inference.
11
7
12
8
learning_objectives:
13
-
- Deploy a lightweight Model Context Protocol (MCP) server on Raspberry Pi 5
14
-
- Design and register custom tools for the AI Agent
15
-
- Create custom endpoints
16
-
- Learn about uv — a fast, efficient Python package manager
9
+
- Deploy a lightweight Model Context Protocol (MCP) server on Raspberry Pi 5 for local AI agent execution.
10
+
- Use the OpenAI Agent SDK to interact with a local AI agent.
11
+
- Design and register custom tools for the agent tasks.
12
+
- Learn about uv — a fast, efficient Python package manager for efficient local deployment.
17
13
18
14
prerequisites:
19
-
- A [Raspberry Pi 5](https://www.raspberrypi.com/products/raspberry-pi-5/)
20
-
- Basic understanding of Python and prompt engineering.
21
-
- Understanding of LLM and AI Agent fundamentals
15
+
- A [Raspberry Pi 5](https://www.raspberrypi.com/products/raspberry-pi-5/) with a Linux-based OS installed.
16
+
- Familiarity with Python programming and prompt engineering techniques.
17
+
- Basic understanding of Large Language Models (LLMs) and how they are used in local inference.
18
+
- Understanding of AI agents and the OpenAI Agent SDK (or similar frameworks).
title: Introduction to Model Context Protocol and uv
2
+
title: Introduction to Model Context Protocol (MCP) and Python uv package for local AI agents
3
3
weight: 2
4
4
5
5
### FIXED, DO NOT MODIFY
@@ -8,27 +8,50 @@ layout: learningpathall
8
8
9
9
## Model Context Protocol (MCP)
10
10
11
-
The **Model Context Protocol (MCP)** is an open specification for wiring Large-Language-Model (LLM) agents to the *context* they need — whether that context is a database, a local sensor, or a SaaS API.
12
-
Think of it as USB-C for AI: once a tool or data source speaks MCP, any compliant LLM client can “plug in” and start using it immediately.
11
+
The Model Context Protocol (MCP) is an open specification designed to connect Large Language Model (LLM) agents to the context they need — including local sensors, databases, and SaaS APIs. It enables on-device AI agents to interact with real-world data through a plug-and-play protocol that works with any LLM framework, including the OpenAI Agent SDK.
13
12
14
13
### Why use MCP?
15
-
-**Plug-and-play integrations:**A growing catalog of pre-built MCP servers (filesystem, shell, vector stores, web-scraping, etc.) gives your agent instant super-powers with zero custom glue code.
14
+
-**Plug-and-play integrations:**a growing catalog of pre-built MCP servers (such as filesystem, shell, vector stores, and web-scraping) gives your agent instant superpowers - no custom integration or glue code required.
16
15
17
-
-**Model/vendor agnostic:**Because the protocol lives outside the model, you can swap models like GPT-4, Claude, or your own fine-tuned model without touching the integration layer.
16
+
-**Model/vendor agnostic:**as the protocol lives outside the model, you can swap models like GPT-4, Claude, or your own fine-tuned model without touching the integration layer.
18
17
19
-
-**Security by design:** MCP encourages running servers inside your own infrastructure, so sensitive data never leaves the perimeter unless you choose.
18
+
-**Security by design:** MCP encourages running servers inside your own infrastructure, so sensitive data stays within your infrastructure unless explicitly shared.
20
19
21
-
-**Cross-ecosystem momentum:**Recent roll-outs—from an official C# SDK to Wix’s production MCP server and Microsoft’s Azure support—show the MCP spec is gathering real-world traction.
20
+
-**Cross-ecosystem momentum:**recent roll-outsfrom an official C# SDK to Wix’s production MCP server and Microsoft’s Azure supportshow the MCP spec is gathering real-world traction.
22
21
23
-
### High-level architecture
24
-
25
-
-**MCP Host:** the LLM-powered application (Claude Desktop, an IDE plugin, OpenAI Agents SDK, etc.).
26
-
-**MCP Client:** the runtime shim that keeps a 1-to-1 connection with each server.
27
-
-**MCP Server:** a lightweight process that advertises tools (functions) over MCP.
28
-
-**Local data sources:** files, databases, or sensors your server can read directly.
29
-
-**Remote services:** external APIs the server can call on the host’s behalf.
22
+
## What is uv?
30
23
31
-
{{% notice Note %}}
32
-
Learn more about AI Agents in the [AI Agent on CPU learning path](https://learn.arm.com/learning-paths/servers-and-cloud-computing/ai-agent-on-cpu/).
24
+
`uv` is a fast, Rust-built Python package manager that simplifies dependency management. It's designed for speed and reliability, making it ideal for setting up local AI agent environments on constrained or embedded devices like the Raspberry Pi 5.
25
+
26
+
Some key features:
27
+
- Built in Rust for performance.
28
+
- Resolves dependencies and installs packages in one step.
29
+
- Optimized for local LLM workloads, embedded AI systems, and containerized Python environments.
30
+
31
+
For further information on `uv`, see: [https://github.com/astral-sh/uv](https://github.com/astral-sh/uv).
32
+
33
+
34
+
## A high-level view of the architecture
35
+
36
+
37
+
38
+
*Figure: High-level view of the architecture of the Model Context Protocol (MCP) for local AI agent integration with real-world data sources.*
39
+
40
+
Each component in the diagram plays a distinct role in enabling AI agents to interact with real-world context:
41
+
42
+
- The **MCP Host** is the LLM-powered application (such as Claude Desktop, an IDE plugin, or an application built with the OpenAI Agents SDK).
43
+
- The **MCP Client** is the runtime shim that keeps a 1-to-1 connection with each server.
44
+
- The **MCP Server** is a lightweight process that advertises tools (functions) over MCP.
45
+
- The **Local data sources** are files, databases, or sensors your server can read directly.
46
+
- The **Remote services** are external APIs the server can call on the host’s behalf.
47
+
48
+
{{% notice Learning Tip %}}
49
+
Learn more about AI Agents in the Learning Path [Deploy an AI Agent on Arm with llama.cpp and llama-cpp-agent using KleidiAI](https://learn.arm.com/learning-paths/servers-and-cloud-computing/ai-agent-on-cpu/).
33
50
{{% /notice %}}
34
51
52
+
## Section summary
53
+
54
+
This page introduces MCP and `uv` as foundational tools for building fast, secure, and modular AI agents that run efficiently on edge devices like the Raspberry Pi 5.
0 commit comments