Anthropic’s Claude Agents —Simple demo of building powerful AI multi-agents using Claude Model Context Protocol (MCP)

Wanna drive your business with AI Agents?

Build Anything with Claude Agents

I’ll show you how you can automate anything with Claude MCP. It allows you to build Claude powered AI Apps way more faster and even much easier there paving the future towards agentic approach.

MCP — Model Context Protocol, which is a protocol used by Claude LLM to interact with external tools and apps. It alleviates the core challenge with building LLM based applications that is intuitively connecting with your own data.

General Architecture

At its core, MCP follows a client-server architecture where a host application can connect to multiple servers:

MCP architecture, Source: https://modelcontextprotocol.io/quickstart; https://x.com/AnthropicAI

• MCP Hosts: Programs like Claude Desktop, IDEs, or AI tools that want to access resources through MCP
• MCP Clients: Protocol clients that maintain 1:1 connections with servers
• MCP Servers: Lightweight programs that each expose specific capabilities through the standardized Model Context Protocol
• Local Resources: Your computer’s resources (databases, files, services) that MCP servers can securely access
• Remote Resources: Resources available over the internet (e.g., through APIs) that MCP servers can connect to

Illustration — Step-by-Step Demo

I will show you exactly how to launch multi-step AI agents with just one prompt. We will see a demo of communicating with your local sqlite database and getting response from the Claude LLM. The diagram below summarizes the workflow.

SQLite Interaction Demo Example, Copyright: https://github.com/modelcontextprotocol

1. Claude Desktop acts as our MCP client
2. A SQLite MCP Server provides secure database access
3. Your local SQLite database stores the actual data

The communication between the SQLite MCP server and your local SQLite database happens entirely on your machine — your SQLite database is not exposed to the internet. The Model Context Protocol ensures that Claude Desktop can only perform approved database operations through well-defined interfaces. This gives you a secure way to let Claude analyze and interact with your local data while maintaining complete control over what it can access.

There are already a number of reference implementations and community-contributed servers available, check them out here.

You can easily roll your own MCP Server and add it to the Claude Desktop configuration file. The python project can be bootstrapped using the helpful create-mcp-server utility.

Getting Started

To try out this simple basic demo, firstly you will need to get all the software pre-requisites installed as listed below.

• The latest version of Claude Desktop installed
• uv 0.4.18 or higher
• Git
• SQLite

# You can download directly download from the url provided and install it on your machine: # uv: https://docs.astral.sh/uv/ # Git: https://git-scm.com # SQLite: https://www.sqlite.org/download.html

Next, we will create a sample test database and insert few records into it followed by configuring the Claude Desktop

1. Create a sample database

Let’s create a simple SQLite database for testing:

# Create a new SQLite database
$sql = @’
CREATE TABLE products (
id INTEGER PRIMARY KEY,
name TEXT,
price REAL
);

INSERT INTO products (name, price) VALUES
(‘Widget’, 19.99),
(‘Gadget’, 29.99),
(‘Gizmo’, 39.99),
(‘Smart Watch’, 199.99),
(‘Wireless Earbuds’, 89.99),
(‘Portable Charger’, 24.99),
(‘Bluetooth Speaker’, 79.99),
(‘Phone Stand’, 15.99),
(‘Laptop Sleeve’, 34.99),
(‘Mini Drone’, 299.99),
(‘LED Desk Lamp’, 45.99),
(‘Keyboard’, 129.99),
(‘Mouse Pad’, 12.99),
(‘USB Hub’, 49.99),
(‘Webcam’, 69.99),
(‘Screen Protector’, 9.99),
(‘Travel Adapter’, 27.99),
(‘Gaming Headset’, 159.99),
(‘Fitness Tracker’, 119.99),
(‘Portable SSD’, 179.99);
‘@

cd ~
& sqlite3 test.db $sql

2. Configure Claude Desktop

Open your Claude Desktop App configuration at %APPDATA%\Claude\claude_desktop_config.json in a text editor.

For example, if you have VS Code installed:

code $env:AppData\Claude\claude_desktop_config.json

Add this configuration (replace YOUR_USERNAME with your actual username):

{
“mcpServers”: {
“sqlite”: {
“command”: “uvx”,
“args”: [
“mcp-server-sqlite”,
“ — db-path”,
“C:\\Users\\YOUR_USERNAME\\test.db”
]
}
}
}

This tells Claude Desktop:

1. There’s an MCP server named “sqlite”
2. Launch it by running uvx mcp-server-sqlite
3. Connect it to your test database

Save the file, and restart Claude Desktop.

Trialing

Let’s verify everything is working. Try sending this prompt to Claude Desktop:

Can you connect to my SQLite database and tell me what products are available,
and their prices?

Claude Desktop will:

1. Connect to the SQLite MCP server
2. Query your local database
3. Format and present the results

Claude Response, Copyright: https://github.com/modelcontextprotocol

Peek behind the scene’s — Understanding

When you interact with Claude Desktop using MCP:

1. Server Discovery: Claude Desktop connects to your configured MCP servers on startup
2. Protocol Handshake: When you ask about data, Claude Desktop:

• Identifies which MCP server can help (sqlite in this case)
• Negotiates capabilities through the protocol
• Requests data or actions from the MCP server

3. Interaction Flow:

4. Security:

• MCP servers only expose specific, controlled capabilities
• MCP servers run locally on your machine, and the resources they access are not exposed to the internet
• Claude Desktop requires user confirmation for sensitive operations

Future of AI — Agentic AI

Kudos to Anthropic team, which has been developing feature after feature, snapping up the attention of the developer communities. First, there came “Artifacts”, followed by “Computer Use”. Now, here comes another revolutionary feature from them: “Model Context Protocol (MCP)”.

Claude’s this massive update makes building AI agents so much easier.
In this blog post, we saw how Anthropic’s released MCP feature basically turns Claude into an API by allowing it to run its own servers.
The Model Context Protocol (MCP) brings a standardized way of allowing interoperability between AI applications, data sources, and other systems. The MCP protocol appears to be a lot like an advanced version of LLM function calling. However, this architecture will make it model agnostic. The abstraction will help with security where you need to expose your legacy or proprietary data to an LLM.

Cheers, Keep Learning…

Let’s get connected

You can reach me at ajay.arunachalam08@gmail.com; Connect via Linkedin

Check out my — Github Repo

Reference

Home

Introducing the Model Context Protocol

GitHub - modelcontextprotocol/python-sdk: The official Python SDK for Model Context Protocol…

Core architecture - Model Context Protocol

Quickstart - Model Context Protocol