How to integrate Adafruit IO MCP with OpenAI Agents SDK

This guide walks you through connecting Adafruit IO to the OpenAI Agents SDK using the Composio tool router. By the end, you'll have a working Adafruit IO agent that can summarize temperature feed anomalies today, publish humidity reading to greenhouse feed, list recent door sensor events through natural language commands. This guide will help you understand how to give your OpenAI Agents SDK agent real control over a Adafruit IO account through Composio's Adafruit IO MCP server. Before we dive in, let's take a quick look at the key ideas and tools involved.

Adafruit IO logoAdafruit IO
Api Key

Adafruit IO is Adafruit's cloud platform for connected device and IoT project data. It helps you store, visualize, and act on sensor feeds without running your own backend.

21 Tools

Introduction

This guide walks you through connecting Adafruit IO to the OpenAI Agents SDK using the Composio tool router. By the end, you'll have a working Adafruit IO agent that can summarize temperature feed anomalies today, publish humidity reading to greenhouse feed, list recent door sensor events through natural language commands.

This guide will help you understand how to give your OpenAI Agents SDK agent real control over a Adafruit IO account through Composio's Adafruit IO MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

Also integrate Adafruit IO with

TL;DR

Here's what you'll learn:
  • Get and set up your OpenAI and Composio API keys
  • Install the necessary dependencies
  • Initialize Composio and create a Tool Router session for Adafruit IO
  • Configure an AI agent that can use Adafruit IO as a tool
  • Run a live chat session where you can ask the agent to perform Adafruit IO operations

What is OpenAI Agents SDK?

The OpenAI Agents SDK is a lightweight framework for building AI agents that can use tools and maintain conversation state. It provides a simple interface for creating agents with hosted MCP tool support.

Key features include:

  • Hosted MCP Tools: Connect to external services through hosted MCP endpoints
  • SQLite Sessions: Persist conversation history across interactions
  • Simple API: Clean interface with Agent, Runner, and tool configuration
  • Streaming Support: Real-time response streaming for interactive applications

What is the Adafruit IO MCP server, and what's possible with it?

The Adafruit IO MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Adafruit IO account. It provides structured and secure access to your feeds, device data, groups, dashboards, and account status, so your agent can publish readings, review data, organize feeds, manage dashboards, and monitor usage on your behalf.

  • Feed creation and management: Have your agent create, review, update, or delete feeds used to store readings from your connected devices.
  • Device data publishing and review: Let the agent publish timestamped values, inspect recent feed data, and retrieve, correct, or remove specific readings.
  • Feed organization with groups: Direct your agent to create and update groups, add or remove feeds, and review how your device feeds are organized.
  • Dashboard management: Instruct your agent to create dashboards for feed data, review existing dashboards and their blocks, update dashboard details, or remove dashboards.
  • Account and usage monitoring: Have your agent check your Adafruit IO account identity, plan limits, and current data write usage before publishing more readings.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step09 STEPS
1

Prerequisites

Before starting, make sure you have:
  • Composio API Key and OpenAI API Key
  • Primary know-how of OpenAI Agents SDK
  • A live Adafruit IO project
  • Some knowledge of Python or Typescript
2

Getting API Keys for OpenAI and Composio

OpenAI API Key
  • Go to the OpenAI dashboard and create an API key. You'll need credits to use the models, or you can connect to another model provider.
  • Keep the API key safe.
Composio API Key
3

Install dependencies

npm install @composio/openai-agents @openai/agents dotenv

Install the Composio SDK and the OpenAI Agents SDK.

4

Set up environment variables

bash
OPENAI_API_KEY=sk-...your-api-key
COMPOSIO_API_KEY=your-api-key
USER_ID=composio_user@gmail.com

Create a .env file and add your OpenAI and Composio API keys.

5

Import dependencies

import 'dotenv/config';
import { Composio } from '@composio/core';
import { OpenAIAgentsProvider } from '@composio/openai-agents';
import { Agent, hostedMcpTool, run, OpenAIConversationsSession } from '@openai/agents';
import * as readline from 'readline';
What's happening:
  • You're importing all necessary libraries.
  • The Composio and OpenAIAgentsProvider classes are imported to connect your OpenAI agent to Composio tools like Adafruit IO.
6

Set up the Composio instance

dotenv.config();

const composioApiKey = process.env.COMPOSIO_API_KEY;
const userId = process.env.USER_ID;

if (!composioApiKey) {
  throw new Error('COMPOSIO_API_KEY is not set. Create a .env file with COMPOSIO_API_KEY=your_key');
}
if (!userId) {
  throw new Error('USER_ID is not set');
}

// Initialize Composio
const composio = new Composio({
  apiKey: composioApiKey,
  provider: new OpenAIAgentsProvider(),
});
What's happening:
  • dotenv.config() loads your .env file so COMPOSIO_API_KEY and USER_ID are available as environment variables.
  • Creating a Composio instance using the API Key and OpenAIAgentsProvider class.
7

Create a Tool Router session

// Create Tool Router session for Adafruit IO
const session = await composio.create(userId as string, {
  toolkits: ['adafruit_io'],
});
const mcpUrl = session.mcp.url;

What is happening:

  • You give the Tool Router the user id and the toolkits you want available. Here, it is only adafruit_io.
  • The router checks the user's Adafruit IO connection and prepares the MCP endpoint.
  • The returned session.mcp.url is the MCP URL that your agent will use to access Adafruit IO.
  • This approach keeps things lightweight and lets the agent request Adafruit IO tools only when needed during the conversation.
8

Configure the agent

// Configure agent with MCP tool
const agent = new Agent({
  name: 'Assistant',
  model: 'gpt-5',
  instructions:
    'You are a helpful assistant that can access Adafruit IO. Help users perform Adafruit IO operations through natural language.',
  tools: [
    hostedMcpTool({
      serverLabel: 'tool_router',
      serverUrl: mcpUrl,
      headers: { 'x-api-key': composioApiKey },
      requireApproval: 'never',
    }),
  ],
});
What's happening:
  • We're creating an Agent instance with a name, model (gpt-5), and clear instructions about its purpose.
  • The agent's instructions tell it that it can access Adafruit IO and help with queries, inserts, updates, authentication, and fetching database information.
  • The tools array includes a hostedMcpTool that connects to the MCP server URL we created earlier.
  • The headers object includes the Composio API key for secure authentication with the MCP server.
  • requireApproval: 'never' means the agent can execute Adafruit IO operations without asking for permission each time, making interactions smoother.
9

Start chat loop and handle conversation

// Keep conversation state across turns
const conversationSession = new OpenAIConversationsSession();

// Simple CLI
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: 'You: ',
});

console.log('\nComposio Tool Router session created.');
console.log('\nChat started. Type your requests below.');
console.log("Commands: 'exit', 'quit', or 'q' to end\n");

try {
  const first = await run(agent, 'What can you help me with?', { session: conversationSession });
  console.log(`Assistant: ${first.finalOutput}\n`);
} catch (e) {
  console.error('Error:', e instanceof Error ? e.message : e, '\n');
}

rl.prompt();

rl.on('line', async (userInput) => {
  const text = userInput.trim();

  if (['exit', 'quit', 'q'].includes(text.toLowerCase())) {
    console.log('Goodbye!');
    rl.close();
    process.exit(0);
  }

  if (!text) {
    rl.prompt();
    return;
  }

  try {
    const result = await run(agent, text, { session: conversationSession });
    console.log(`\nAssistant: ${result.finalOutput}\n`);
  } catch (e) {
    console.error('Error:', e instanceof Error ? e.message : e, '\n');
  }

  rl.prompt();
});

rl.on('close', () => {
  console.log('\n👋 Session ended.');
  process.exit(0);
});
What's happening:
  • The program prints a session URL that you visit to authorize Adafruit IO.
  • After authorization, the chat begins.
  • Each message you type is processed by the agent using run().
  • The responses are printed to the console.
  • Typing exit, quit, or q cleanly ends the chat.

Complete Code

Here's the complete code to get you started with Adafruit IO and OpenAI Agents SDK:

import 'dotenv/config';
import { Composio } from '@composio/core';
import { OpenAIAgentsProvider } from '@composio/openai-agents';
import { Agent, hostedMcpTool, run, OpenAIConversationsSession } from '@openai/agents';
import * as readline from 'readline';

const composioApiKey = process.env.COMPOSIO_API_KEY;
const userId = process.env.USER_ID;

if (!composioApiKey) {
  throw new Error('COMPOSIO_API_KEY is not set. Create a .env file with COMPOSIO_API_KEY=your_key');
}
if (!userId) {
  throw new Error('USER_ID is not set');
}

// Initialize Composio
const composio = new Composio({
  apiKey: composioApiKey,
  provider: new OpenAIAgentsProvider(),
});

async function main() {
  // Create Tool Router session
  const session = await composio.create(userId as string, {
    toolkits: ['adafruit_io'],
  });
  const mcpUrl = session.mcp.url;

  // Configure agent with MCP tool
  const agent = new Agent({
    name: 'Assistant',
    model: 'gpt-5',
    instructions:
      'You are a helpful assistant that can access Adafruit IO. Help users perform Adafruit IO operations through natural language.',
    tools: [
      hostedMcpTool({
        serverLabel: 'tool_router',
        serverUrl: mcpUrl,
        headers: { 'x-api-key': composioApiKey },
        requireApproval: 'never',
      }),
    ],
  });

  // Keep conversation state across turns
  const conversationSession = new OpenAIConversationsSession();

  // Simple CLI
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: 'You: ',
  });

  console.log('\nComposio Tool Router session created.');
  console.log('\nChat started. Type your requests below.');
  console.log("Commands: 'exit', 'quit', or 'q' to end\n");

  try {
    const first = await run(agent, 'What can you help me with?', { session: conversationSession });
    console.log(`Assistant: ${first.finalOutput}\n`);
  } catch (e) {
    console.error('Error:', e instanceof Error ? e.message : e, '\n');
  }

  rl.prompt();

  rl.on('line', async (userInput) => {
    const text = userInput.trim();

    if (['exit', 'quit', 'q'].includes(text.toLowerCase())) {
      console.log('Goodbye!');
      rl.close();
      process.exit(0);
    }

    if (!text) {
      rl.prompt();
      return;
    }

    try {
      const result = await run(agent, text, { session: conversationSession });
      console.log(`\nAssistant: ${result.finalOutput}\n`);
    } catch (e) {
      console.error('Error:', e instanceof Error ? e.message : e, '\n');
    }

    rl.prompt();
  });

  rl.on('close', () => {
    console.log('\nSession ended.');
    process.exit(0);
  });
}

main().catch((err) => {
  console.error('Fatal error:', err);
  process.exit(1);
});

Conclusion

This was a starter code for integrating Adafruit IO MCP with OpenAI Agents SDK to build a functional AI agent that can interact with Adafruit IO.

Key features:

  • Hosted MCP tool integration through Composio's Tool Router
  • SQLite session persistence for conversation history
  • Simple async chat loop for interactive testing
You can extend this by adding more toolkits, implementing custom business logic, or building a web interface around the agent.
TOOLS

Supported Tools

Every Adafruit IO action and event your agent gets out of the box.

Add Feeds to Group

Sequentially add 1-10 existing feeds to one group using one documented provider request per feed.

Create Dashboard

Create a dashboard for visualizing and controlling feed data.

Create Feed

Create a feed, optionally within an existing group.

Create Group

Create a group for organizing feeds.

Delete Dashboard

Permanently delete one dashboard by exact key.

Delete Data Point

Permanently delete one feed data point by ID.

Delete Data Points

Permanently delete 1-30 feed data points sequentially through Adafruit IO's single-data-point DELETE endpoint, bounded by the Free-plan limit of 30 data mutations per minute.

Delete Feed

Permanently delete one feed and its retained data by exact feed key.

Delete Group

Permanently delete one group by exact key.

Get Account Status

Return compact identity, plan limits, and current data-write throttle usage for the connected Adafruit IO account.

Get Dashboards

List dashboards, or retrieve one dashboard and its blocks by key.

Get Data Point

Retrieve one feed data point by its exact ID.

Get Feeds

List feeds, or retrieve one feed by key with optional data summary details.

Get Groups

List groups with feed summaries, or retrieve one group by key.

List Feed Data

Return one newest-first page of feed data with an opaque cursor for the next older page.

Publish Feed Data

Publish one or multiple timestamped values to a feed, using the batch endpoint only when multiple points are supplied.

Remove Feeds from Group

Sequentially remove 1-10 feeds from one group using one documented provider request per feed.

Update Dashboard

Update an existing dashboard by exact dashboard key.

Update Data Point

Replace the value and optional metadata of one existing feed data point.

Update Feed

Update an existing feed by exact feed key.

Update Group

Update an existing group by exact group key.

FAQ

Frequently asked questions

With a standalone Adafruit IO MCP server, the agents and LLMs can only access a fixed set of Adafruit IO tools tied to that server. However, with the Composio Tool Router, agents can dynamically load tools from Adafruit IO and many other apps based on the task at hand, all through a single MCP endpoint.

Yes, you can. OpenAI Agents SDK fully supports MCP integration. You get structured tool calling, message history handling, and model orchestration while Tool Router takes care of discovering and serving the right Adafruit IO tools.

Yes, absolutely. You can configure which Adafruit IO scopes and actions are allowed when connecting your account to Composio. You can also bring your own OAuth credentials or API configuration so you keep full control over what the agent can do.

All sensitive data such as tokens, keys, and configuration is fully encrypted at rest and in transit. Composio is SOC 2 Type 2 compliant and follows strict security practices so your Adafruit IO data and credentials are handled as safely as possible.

Start with Adafruit IO.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Adafruit IO tool your agent needs.Free to start.

Start building