How to integrate Proabono MCP with LlamaIndex

This guide walks you through connecting Proabono to LlamaIndex using the Composio tool router. By the end, you'll have a working Proabono agent that can list all active subscriptions for a customer, create a new subscription for acme corp, show overdue invoices for a specific customer through natural language commands. This guide will help you understand how to give your LlamaIndex agent real control over a Proabono account through Composio's Proabono MCP server. Before we dive in, let's take a quick look at the key ideas and tools involved.

Get started for free Get a demo

Proabono

Basic

Proabono is a smart subscription management platform that automates billing and recurring payments. It streamlines your subscription operations and customer lifecycle.

67 Tools

Managed auth

Connect Proabono without auth hassles

We manage OAuth, API keys, token refresh, and scopes — you just build.

Try for free

Introduction

This guide will help you understand how to give your LlamaIndex agent real control over a Proabono account through Composio's Proabono MCP server.

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

Also integrate Proabono with

OpenAI Agents SDK Claude Agent SDK Claude Code Claude Cowork Codex OpenClaw Hermes CLI Google ADK LangChain Vercel AI SDK Mastra AI CrewAI

TL;DR

Here's what you'll learn:

Set your OpenAI and Composio API keys
Install LlamaIndex and Composio packages
Create a Composio Tool Router session for Proabono
Connect LlamaIndex to the Proabono MCP server
Build a Proabono-powered agent using LlamaIndex
Interact with Proabono through natural language

What is LlamaIndex?

LlamaIndex is a data framework for building LLM applications. It provides tools for connecting LLMs to external data sources and services through agents and tools.

Key features include:

ReAct Agent: Reasoning and acting pattern for tool-using agents
MCP Tools: Native support for Model Context Protocol
Context Management: Maintain conversation context across interactions
Async Support: Built for async/await patterns

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

The Proabono MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Proabono account. It provides structured and secure access so your agent can perform Proabono operations on your behalf.

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:

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

Step-by-step Guide

Step by step10 STEPS

Prerequisites

Before you begin, make sure you have:

Python 3.8/Node 16 or higher installed
A Composio account with the API key
An OpenAI API key
A Proabono account and project
Basic familiarity with async Python/Typescript

Getting API Keys for OpenAI, Composio, and Proabono

OpenAI API key (OPENAI_API_KEY)

Go to the OpenAI dashboard
Create an API key if you don't have one
Assign it to OPENAI_API_KEY in .env

Composio API key and user ID

Log into the Composio dashboard
Copy your API key from Settings
- Use this as COMPOSIO_API_KEY
Pick a stable user identifier (email or ID)
- Use this as COMPOSIO_USER_ID

Installing dependencies

npm install @composio/llamaindex @llamaindex/openai @llamaindex/tools @llamaindex/workflow dotenv

Create a new Typescript project and install the necessary dependencies:

@composio/llamaindex: Composio's LlamaIndex integration
@llamaindex/openai: OpenAI LLM integration
@llamaindex/tools: MCP client for LlamaIndex
@llamaindex/workflow: Workflow framework for LlamaIndex
dotenv: Environment variable management

Set environment variables

bash

OPENAI_API_KEY=your-openai-api-key
COMPOSIO_API_KEY=your-composio-api-key
COMPOSIO_USER_ID=your-user-id

Create a .env file in your project root:

These credentials will be used to:

Authenticate with OpenAI's GPT-5 model
Connect to Composio's Tool Router
Identify your Composio user session for Proabono access

Import modules

import "dotenv/config";
import readline from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";

import { Composio } from "@composio/core";

import { mcp } from "@llamaindex/tools";
import { agent as createAgent } from "@llamaindex/workflow";
import { openai } from "@llamaindex/openai";

dotenv.config();

Create a new file called proabono_llamaindex_agent.ts and import the required modules:

Key imports:

dotenv.config loads .env at runtime
readline gives us a simple CLI chat loop
Composio is the main Composio SDK client
mcp connects to an MCP endpoint
createAgent builds a LlamaIndex agent
openai configures the LLM backend

Load environment variables and initialize Composio

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const COMPOSIO_API_KEY = process.env.COMPOSIO_API_KEY;
const COMPOSIO_USER_ID = process.env.COMPOSIO_USER_ID;

if (!OPENAI_API_KEY) throw new Error("OPENAI_API_KEY is not set");
if (!COMPOSIO_API_KEY) throw new Error("COMPOSIO_API_KEY is not set");
if (!COMPOSIO_USER_ID) throw new Error("COMPOSIO_USER_ID is not set");

What's happening:

This ensures missing credentials cause early, clear errors before the agent attempts to initialise.

Create a Tool Router session and build the agent function

async function buildAgent() {

  console.log(`Initializing Composio client...${COMPOSIO_USER_ID!}...`);
  console.log(`COMPOSIO_USER_ID: ${COMPOSIO_USER_ID!}...`);

  const composio = new Composio({
    apiKey: COMPOSIO_API_KEY,
    provider: new LlamaindexProvider(),
  });

  const session = await composio.create(
    COMPOSIO_USER_ID!,
    {
      toolkits: ["proabono"],
    },
  );

  const mcpUrl = session.mcp.url;
  console.log(`Composio Tool Router MCP URL: ${mcpUrl}`);

  const server = mcp({
    url: mcpUrl,
    clientName: "composio_tool_router_with_llamaindex",
    requestInit: {
      headers: {
        "x-api-key": COMPOSIO_API_KEY!,
      },
    },
    // verbose: true,
  });

  const tools = await server.tools();

  const llm = openai({ apiKey: OPENAI_API_KEY, model: "gpt-5" });

  const agent = createAgent({
    name: "composio_tool_router_with_llamaindex",
        description : "An agent that uses Composio Tool Router MCP tools to perform actions.",
    systemPrompt:
      "You are a helpful assistant connected to Composio Tool Router."+
"Use the available tools to answer user queries and perform Proabono actions." ,
    llm,
    tools,
  });

  return agent;
}

What's happening here:

We create a Composio client using your API key and configure it with the LlamaIndex provider
We then create a tool router MCP session for your user, specifying the toolkits we want to use (in this case, proabono)
The session returns an MCP HTTP endpoint URL that acts as a gateway to all your configured tools
LlamaIndex will connect to this endpoint to dynamically discover and use the available Proabono tools.
The MCP tools are mapped to LlamaIndex-compatible tools and plug them into the Agent.

Create an interactive chat loop

async function chatLoop(agent: ReturnType<typeof createAgent>) {
  const rl = readline.createInterface({ input, output });

  console.log("Type 'quit' or 'exit' to stop.");

  while (true) {
    let userInput: string;

    try {
      userInput = (await rl.question("\nYou: ")).trim();
    } catch {
      console.log("\nAgent: Bye!");
      break;
    }

    if (!userInput) {
      continue;
    }

    const lower = userInput.toLowerCase();
    if (lower === "quit" || lower === "exit") {
      console.log("Agent: Bye!");
      break;
    }

    try {
      process.stdout.write("Agent: ");

      const stream = agent.runStream(userInput);
      let finalResult: any = null;

      for await (const event of stream) {
        // The event.data contains the streamed content
        const data: any = event.data;

        // Check for streaming delta content
        if (data?.delta) {
          process.stdout.write(data.delta);
        }

        // Store final result for fallback
        if (data?.result || data?.message) {
          finalResult = data;
        }
      }

      // If no streaming happened, show the final result
      if (finalResult) {
        const answer =
          finalResult.result ??
          finalResult.message?.content ??
          finalResult.message ??
          "";
        if (answer && typeof answer === "string" && !answer.includes("[object")) {
          process.stdout.write(answer);
        }
      }

      console.log(); // New line after streaming completes
    } catch (err: any) {
      console.error("\nAgent error:", err?.message ?? err);
    }
  }

  rl.close();
}

What's happening:

We're creating a direct terminal interface to chat with Proabono
The LLM's responses are streamed to the CLI for faster interaction.
The agent uses context to maintain conversation history
The agent processes the request, selects appropriate Proabono tools, and returns a result
We extract the answer from the result data structure and display it to the user
You can type 'quit' or 'exit' to stop the chat loop gracefully
Agent responses and any errors are streamed in a clear, readable format

Define the main entry point

async function main() {
  try {
    const agent = await buildAgent();
    await chatLoop(agent);
  } catch (err) {
    console.error("Failed to start agent:", err);
    process.exit(1);
  }
}

main();

What's happening here:

We're orchestrating the entire application flow
The agent gets built with proper error handling
Then we kick off the interactive chat loop so you can start talking to Proabono

Run the agent

npx ts-node llamaindex-agent.ts

When prompted, authenticate and authorise your agent with Proabono, then start asking questions.

Complete Code

Here's the complete code to get you started with Proabono and LlamaIndex:

import "dotenv/config";
import readline from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";

import { Composio } from "@composio/core";
import { LlamaindexProvider } from "@composio/llamaindex";

import { mcp } from "@llamaindex/tools";
import { agent as createAgent } from "@llamaindex/workflow";
import { openai } from "@llamaindex/openai";

dotenv.config();

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const COMPOSIO_API_KEY = process.env.COMPOSIO_API_KEY;
const COMPOSIO_USER_ID = process.env.COMPOSIO_USER_ID;

if (!OPENAI_API_KEY) {
    throw new Error("OPENAI_API_KEY is not set in the environment");
  }
if (!COMPOSIO_API_KEY) {
    throw new Error("COMPOSIO_API_KEY is not set in the environment");
  }
if (!COMPOSIO_USER_ID) {
    throw new Error("COMPOSIO_USER_ID is not set in the environment");
  }

async function buildAgent() {

  console.log(`Initializing Composio client...${COMPOSIO_USER_ID!}...`);
  console.log(`COMPOSIO_USER_ID: ${COMPOSIO_USER_ID!}...`);

  const composio = new Composio({
    apiKey: COMPOSIO_API_KEY,
    provider: new LlamaindexProvider(),
  });

  const session = await composio.create(
    COMPOSIO_USER_ID!,
    {
      toolkits: ["proabono"],
    },
  );

  const mcpUrl = session.mcp.url;
  console.log(`Composio Tool Router MCP URL: ${mcpUrl}`);

  const server = mcp({
    url: mcpUrl,
    clientName: "composio_tool_router_with_llamaindex",
    requestInit: {
      headers: {
        "x-api-key": COMPOSIO_API_KEY!,
      },
    },
    // verbose: true,
  });

  const tools = await server.tools();

  const llm = openai({ apiKey: OPENAI_API_KEY, model: "gpt-5" });

  const agent = createAgent({
    name: "composio_tool_router_with_llamaindex",
    description:
      "An agent that uses Composio Tool Router MCP tools to perform actions.",
    systemPrompt:
      "You are a helpful assistant connected to Composio Tool Router."+
"Use the available tools to answer user queries and perform Proabono actions." ,
    llm,
    tools,
  });

  return agent;
}

async function chatLoop(agent: ReturnType<typeof createAgent>) {
  const rl = readline.createInterface({ input, output });

  console.log("Type 'quit' or 'exit' to stop.");

  while (true) {
    let userInput: string;

    try {
      userInput = (await rl.question("\nYou: ")).trim();
    } catch {
      console.log("\nAgent: Bye!");
      break;
    }

    if (!userInput) {
      continue;
    }

    const lower = userInput.toLowerCase();
    if (lower === "quit" || lower === "exit") {
      console.log("Agent: Bye!");
      break;
    }

    try {
      process.stdout.write("Agent: ");

      const stream = agent.runStream(userInput);
      let finalResult: any = null;

      for await (const event of stream) {
        // The event.data contains the streamed content
        const data: any = event.data;

        // Check for streaming delta content
        if (data?.delta) {
          process.stdout.write(data.delta);
        }

        // Store final result for fallback
        if (data?.result || data?.message) {
          finalResult = data;
        }
      }

      // If no streaming happened, show the final result
      if (finalResult) {
        const answer =
          finalResult.result ??
          finalResult.message?.content ??
          finalResult.message ??
          "";
        if (answer && typeof answer === "string" && !answer.includes("[object")) {
          process.stdout.write(answer);
        }
      }

      console.log(); // New line after streaming completes
    } catch (err: any) {
      console.error("\nAgent error:", err?.message ?? err);
    }
  }

  rl.close();
}

async function main() {
  try {
    const agent = await buildAgent();
    await chatLoop(agent);
  } catch (err: any) {
    console.error("Failed to start agent:", err?.message ?? err);
    process.exit(1);
  }
}

main();

Conclusion

You've successfully connected Proabono to LlamaIndex through Composio's Tool Router MCP layer. Key takeaways:

Tool Router dynamically exposes Proabono tools through an MCP endpoint
LlamaIndex's ReActAgent handles reasoning and orchestration; Composio handles integrations
The agent becomes more capable without increasing prompt size
Async Python provides clean, efficient execution of agent workflows

You can easily extend this to other toolkits like Gmail, Notion, Stripe, GitHub, and more by adding them to the toolkits parameter.

TOOLS

Supported Tools

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

Anonymize Customer

Tool to anonymize a customer for GDPR compliance.

Bill Customer

Tool to trigger billing for a customer.

Create Customer

Tool to create or declare a customer in ProAbono via the Backoffice API.

Create Feature

Tool to create a new feature in ProAbono via the Backoffice API.

Delete Customer

Tool to delete a customer from ProAbono by ID.

Delete Offer

Tool to delete an offer from ProAbono by ID.

Delete Pricing Table

Tool to delete a pricing table from ProAbono by its ID.

Delete Pricing Table Offer

Tool to delete a pricing table offer via the ProAbono Backoffice API.

Delete Subscription Discount

Tool to delete a subscription discount via the Backoffice API.

Enable Webhook

Tool to enable a webhook in ProAbono via the Notification API.

Get Customer by ID

Tool to retrieve a single customer by ID from ProAbono Backoffice API.

Get Customer Billing Address

Tool to retrieve a customer's billing address via the Backoffice API.

Get Customer Billing Address by Reference

Tool to retrieve the billing address for a customer by reference from ProAbono API.

Get Customer by Reference

Tool to retrieve a customer by their reference identifier from ProAbono API.

Get Customer Payment Settings

Tool to retrieve customer payment settings via the Backoffice API.

Get Discount

Tool to retrieve a discount by ID via the Backoffice API.

Get Feature by ID

Tool to retrieve a feature by ID from ProAbono Backoffice API.

Get Feature by Reference

Tool to retrieve a single feature by its reference from ProAbono API.

Get Invoice

Tool to retrieve a specific invoice or credit note by ID from ProAbono.

Get Offer by ID

Tool to retrieve a single offer by its ID from ProAbono Backoffice API.

Get Subscription by Customer Reference

Tool to retrieve a subscription by customer reference from ProAbono.

Get Subscription Creation Quote

Tool to get a pricing quote for creating a new subscription without actually creating it.

Get Usage Record

Tool to retrieve a single usage record for a specific feature and customer combination from ProAbono.

Get Usages for Customer

Tool to retrieve usage data for customers from ProAbono.

Invalidate Customer

Tool to invalidate a customer by their reference.

Invalidate Customer by ID

Tool to invalidate a customer by their ProAbono internal ID.

List Balance Lines

Tool to list all balance lines from ProAbono.

List Businesses

Tool to list all businesses from ProAbono via the Backoffice API.

List Business Localization

Tool to list localization entries by business from ProAbono via the HostedPages API.

List Customer Moves

Tool to list all customer balance moves via the ProAbono Backoffice API.

List Customers

Tool to list all customers from ProAbono via the Backoffice API.

List Customers by Feature

Tool to list customers that have access to a specific feature via the ProAbono API.

List Discounts

Tool to list all discounts from ProAbono's Backoffice API.

List Features

Tool to list all features via the ProAbono Backoffice API.

List Features (V1)

Tool to retrieve all features from ProAbono API using the /v1/Features endpoint.

List Gateway Accounts

Tool to list payment gateway accounts from ProAbono Backoffice API.

List Gateway Permissions

Tool to list gateway permissions from ProAbono API.

List Gateway Requests

Tool to list gateway requests from ProAbono.

List Gateway Transactions

Tool to list gateway transactions from ProAbono.

List Invoice Lines

Tool to list all invoice lines from ProAbono via the Backoffice API.

List Invoices and Credit Notes

Tool to list all invoices and credit notes from ProAbono Backoffice API.

List Invoices by Customer Reference

Tool to list invoices for a specific customer by their reference identifier from ProAbono API.

List Offers

Tool to list all subscription offers (plans) from ProAbono Backoffice API.

List Payments

Tool to list all payments from ProAbono Backoffice API.

List Pricing Table Offers

Tool to list all pricing table offers via the ProAbono Backoffice API.

List Pricing Tables

Tool to list all pricing tables from ProAbono Backoffice API.

List Segment Localizations

Tool to list localization entries by segment from ProAbono Backoffice API.

List Segments

Tool to list all segments from ProAbono via the Backoffice API.

List Subscription Discounts

Tool to list all subscription discounts via the ProAbono Backoffice API.

List Subscription Features

Tool to list all subscription features via the ProAbono Backoffice API.

List Subscription Periods

Tool to list all subscription periods (billing cycles) from ProAbono Backoffice API.

List Subscriptions

Tool to list all subscriptions from ProAbono via the Backoffice API.

List Subscriptions (V1)

Tool to retrieve all subscriptions from ProAbono API using the /v1/Subscriptions endpoint.

List Tax Profile Exceptions

Tool to list tax profile exceptions from ProAbono Organization API.

List Tax Profiles

Tool to list all tax profiles from ProAbono via the Backoffice API.

List Upgrade Offers

Tool to retrieve offers available to upgrade an existing customer subscription.

List Webhook Notifications

Tool to list webhook notifications from ProAbono via the Notification API.

List Webhooks

Tool to list webhooks from ProAbono Notification API.

Quote Balance Line Creation

Tool to get a pricing quote for creating a balance line (one-time charge or credit).

Revoke Customer Portal Links

Tool to revoke encrypted customer portal links and generate new ones in ProAbono.

Update Business Billing Address

Tool to update business billing address via the Backoffice API.

Update Customer

Tool to update an existing customer in ProAbono via the Backoffice API.

Update Customer Billing Address

Tool to update the billing address for a customer in ProAbono via the API.

Update Customer Payment Settings

Tool to update payment settings for a specific customer in ProAbono.

Update Customer Shipping Address

Tool to update customer shipping address via the Backoffice API.

Update Feature

Tool to update an existing feature in ProAbono via the Backoffice API.

Update Tax Profiles

Tool to update an existing tax profile in ProAbono via the Backoffice API.

FRAMEWORKS

How to build Proabono MCP Agent with another framework

OpenAI Agents SDK

Use Proabono MCP with OpenAI Agents SDK

Claude Agent SDK

Use Proabono MCP with Claude Agent SDK

Claude Code

Use Proabono MCP with Claude Code

Claude Cowork

Use Proabono MCP with Claude Cowork

Codex

Use Proabono MCP with Codex

OpenClaw

Use Proabono MCP with OpenClaw

Hermes

Use Proabono MCP with Hermes

CLI

Use Proabono MCP with CLI

Google ADK

Use Proabono MCP with Google ADK

LangChain

Use Proabono MCP with LangChain

Vercel AI SDK

Use Proabono MCP with Vercel AI SDK

Mastra AI

Use Proabono MCP with Mastra AI

CrewAI

Use Proabono MCP with CrewAI

MORE TOOLKITS

Explore Other Toolkits

Toolkit marketplace

Google Sheets

Oauth2

Google Sheets is a cloud-based spreadsheet tool for real-time collaboration and data analysis. It lets teams work together from anywhere, updating information instantly.

Notion

Oauth2Api Key

Notion is a collaborative workspace for notes, docs, wikis, and tasks. It streamlines team knowledge, project tracking, and workflow customization in one place.

Airtable

Oauth2Api Key

Airtable combines the flexibility of spreadsheets with the power of a database for easy project and data management. Teams use Airtable to organize, track, and collaborate with custom views and automations.

Asana

Oauth2

Asana is a collaborative work management platform for teams to organize and track projects. It streamlines teamwork, boosts productivity, and keeps everyone aligned on goals.

FAQ

Frequently asked questions

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

Yes, you can. LlamaIndex 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 Proabono tools.

Yes, absolutely. You can configure which Proabono 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 Proabono data and credentials are handled as safely as possible.

Start with Proabono.It takes 30 seconds.

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

Start building

Customer stories

Teams ship real agents on Composio

GET STARTED FOR FREE BOOK A DEMO

Karan skipped his own birthday party to fix our critical issue. It was 10pm and he diverted his Waymo to help us instead. This really sets the bar — it shows the commitment you need when users rely on your software.

Harsha Gaddipati

Co-founder, Slashy

A lot of students tell us that the moment their connected tools start talking to each other inside Opennote feels almost magical. The agent just knows them, and it's immensely helped keep new users on the platform.

Abhi Arya

Co-founder, Opennote

We chose Composio over Pipedream because it delivered depth where it mattered — niche tools and tricky edge cases other platforms simply ignored. That gave us confidence to scale without compromising.

Nirman Dave

CEO, Zams

As a solo builder, shipping fast is life or death. The only way I can outcompete incumbents is by outmanoeuvring them. Getting bogged down managing agent auth would have been a death sentence.

Ryan Yu

Founder, Extra Thursday

Before Composio, adding tool integrations was slow and resource-intensive. Each one could take weeks of engineering time, and maintaining them meant constantly keeping up with API changes.

Tomisin Jenrola

Founder & CEO, SwarmZero

With hands-on help from their founder, we integrated Gmail and Google Drive in just 30 minutes. This level of personal support and commitment is exactly what startups should strive for.

Jerome Leclanche

Co-Founder, Ingram Technologies