DEV Community

Cover image for How to Use MCP Agents to Access Multiple Data Stores
Bronto profile image Patrick Londa
Patrick Londa for Bronto

Posted on • Originally published at bronto.io

How to Use MCP Agents to Access Multiple Data Stores

#ai #agents #mcp #python

Authored by David Tracey

This is Part 2 of a three-part series on the Agent2Agent (A2A) protocol and agentic data querying. Part 1 introduced A2A concepts and showed how to build a basic agent. This post demonstrates how easy it is to create two simple MCP agents to query different data sources and then analyse their outputs using Claude.

The scenario: when an employee leaves a company, the IT department needs to verify their details and access have been removed from all systems — in this case, an HR database and a logging platform. Traditionally, an IT person would check each system separately using custom tools. We'll show how MCP makes this dramatically simpler.

Architecture Overview

We'll create:

  1. A Bronto REST API client to fetch users from Bronto
  2. A SQLite database server representing HR data
  3. Two MCP servers wrapping each data source
  4. A demonstration of Claude using both MCP servers to answer a query

MCP architecture diagram

You can set up a 14-day free trial to test the Bronto REST API client used here.

Step 1: Create a Bronto REST API Client 

# bronto_client.py
import json
import logging
from requests import Session
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

ADMIN_API_KEY = "SomeKey"
DATA_STORAGE_REGION = 'us'  # swap for your region

def get_users(s: Session) -> None:
    response = s.get(
        f"https://api.{DATA_STORAGE_REGION}.brontobytes.io/users",
        headers={'X-BRONTO-API-KEY': ADMIN_API_KEY}
    )
    print(json.dumps(response.json(), indent=4))

if __name__ == '__main__':
    session = Session()
    session.mount(
        f'https://api.{DATA_STORAGE_REGION}.brontobytes.io',
        HTTPAdapter(max_retries=Retry(total=3, backoff_factor=1,
                                      status_forcelist=[500, 502, 503, 504]))
    )
    get_users(session)
Enter fullscreen mode Exit fullscreen mode

Run it:

python -m venv ./env && source ./env/bin/activate && pip install requests
python bronto_client.py
Enter fullscreen mode Exit fullscreen mode

This returns a JSON response with all users in your Bronto account:

{
  "users": [
    {
      "id": "00000ffff",
      "first_name": "Paul",
      "last_name": "McCartney",
      "email": "paul@beatles.io",
      "roles": ["1111", "Admin"],
      "status": "ACTIVE",
      "tags": { "team": "fabfour" }
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

Step 2: Create a Simple Employee Database

Install SQLite (or use brew install sqlite on Mac), then create the database:

sqlite3 bronto_employee.db
Enter fullscreen mode Exit fullscreen mode 
CREATE TABLE Employee (
  Id INTEGER PRIMARY KEY AUTOINCREMENT,
  FirstName TEXT NOT NULL,
  LastName TEXT NOT NULL,
  HireDate DATE NOT NULL
);

INSERT INTO Employee (FirstName, LastName, HireDate) VALUES
  ('Paul', 'McCartney', '2025-07-22'),
  ('Ringo', 'Starr', '2024-10-22'),
  ('George', 'Harrison', '2024-06-01'),
  ('John', 'Lennon', '2025-11-05');
Enter fullscreen mode Exit fullscreen mode

Step 3: Wrap Both Sources as MCP Servers

We'll use FastMCP to expose each data source as an MCP tool.

Bronto MCP Server 

# mcp-bronto-user-get.py
import json
from requests import Session
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Bronto Users")

ADMIN_API_KEY = "SomeKey"
DATA_STORAGE_REGION = 'us'

@mcp.tool()
def get_bronto_users():
    session = Session()
    session.mount(
        f'https://api.{DATA_STORAGE_REGION}.brontobytes.io',
        HTTPAdapter(max_retries=Retry(total=3, backoff_factor=1,
                                      status_forcelist=[500, 502, 503, 504]))
    )
    response = session.get(
        f"https://api.{DATA_STORAGE_REGION}.brontobytes.io/users",
        headers={'X-BRONTO-API-KEY': ADMIN_API_KEY}
    )
    return response.json()

if __name__ == '__main__':
    mcp.run(transport="sse", host="127.0.0.1", port=8080)
Enter fullscreen mode Exit fullscreen mode

Run the server:

python -m venv ./env && source ./env/bin/activate && pip install fastmcp
fastmcp run mcp-bronto-user-get-server.py:mcp --transport sse --port 8080 --host 0.0.0.0
Enter fullscreen mode Exit fullscreen mode

SQLite Employee MCP Server 

# sqlite-server.py
from fastmcp import FastMCP
import sqlite3

mcp = FastMCP("Employee DB")

@mcp.tool()
def get_employees():
    conn = sqlite3.connect('/your_path/bronto_employee.db')
    cursor = conn.cursor()
    cursor.execute("SELECT LastName, FirstName FROM Employee ORDER BY HireDate DESC")
    results = cursor.fetchall()
    conn.close()
    return [{"LastName": ln, "FirstName": fn} for ln, fn in results]

if __name__ == '__main__':
    mcp.run()
Enter fullscreen mode Exit fullscreen mode

Run the server on port 8081:

FastMCP run -p 8081 -t sse sqlite-test-server.py
Enter fullscreen mode Exit fullscreen mode

Inspecting MCP Servers

The FastMCP CLI has a useful inspect command:

FastMCP inspect sqlite-test-server.py
Enter fullscreen mode Exit fullscreen mode

This shows available tools, prompts, resources, and a full inspection log.

Step 4: Connect Both Servers to Claude

Install Claude locally, then add both MCP servers to Claude's config file. On Mac: ~/Library/Application Support/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "EmployeeDB": {
      "command": "/your_path/mcp-env/bin/python",
      "args": ["/your_path/mcp-sqlite-server.py"],
      "description": "A simple MCP server to query employee data from a database"
    },
    "BrontoUsers": {
      "command": "/your_path/mcp-env/bin/python",
      "args": ["/your_path/mcp-bronto-user-get.py"],
      "description": "A simple MCP server to query Bronto Users"
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Verify the servers are loaded in Claude under Settings → Developer → Local MCP Servers.

Step 5: Query Both Data Sources with One Prompt

Enter this prompt in Claude:

Show me Bronto employees, check if they have Bronto user accounts and summarise what you find

Claude uses both MCP servers and returns something like:

Summary of Bronto Employees and User Accounts

Employee Database: 4 employees total

Bronto User Accounts: 8 active user accounts

Employees WITH Bronto accounts (3 out of 4):

  1. Paul McCartney — 2 accounts (@beatles.io, @wings.io) — Admin role
  2. George Harrison — 2 accounts (@beatles.io, @wilburys.io) — Admin
  3. John Lennon — 4 accounts (various domains) — Admin/ReadOnly roles

Employee WITHOUT Bronto account:

  • Ringo Starr — No user account found

Key Findings:

  • 75% coverage — 3 of 4 employees have Bronto accounts
  • Most employees have multiple accounts (likely testing/different environments)
  • Additional users not in the employee list suggest external contractors or an incomplete employee list

Why This Matters

As this simple demo shows, MCP makes it easy to query multiple, disparate data sources from a single LLM prompt — without moving any data. Logs stay in Bronto (optimized for fast search at scale) and HR data stays in SQL (optimized for tabular queries). Each data source is accessed by an agent purpose-built for it.

This benefit compounds as the number of data stores and agents grows.

Part 3 will extend this scenario by adding A2A, giving us a "SuperAgent" that can autonomously discover and orchestrate these data source agents without relying on Claude as the coordinator.

Start a Free Bronto Trial

Top comments (0)