How to integrate Zoho inventory MCP with Autogen

Trusted by
AWS
Glean
Zoom
Airtable

30 min · no commitment · see it on your stack

Zoho inventory logo
AutoGen logo
divider

Introduction

This guide walks you through connecting Zoho inventory to AutoGen using the Composio tool router. By the end, you'll have a working Zoho inventory agent that can check current stock for a specific item, list all pending sales orders today, create a new purchase order for supplier through natural language commands.

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

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

Also integrate Zoho inventory with

TL;DR

Here's what you'll learn:
  • Get and set up your OpenAI and Composio API keys
  • Install the required dependencies for Autogen and Composio
  • Initialize Composio and create a Tool Router session for Zoho inventory
  • Wire that MCP URL into Autogen using McpWorkbench and StreamableHttpServerParams
  • Configure an Autogen AssistantAgent that can call Zoho inventory tools
  • Run a live chat loop where you ask the agent to perform Zoho inventory operations

What is AutoGen?

Autogen is a framework for building multi-agent conversational AI systems from Microsoft. It enables you to create agents that can collaborate, use tools, and maintain complex workflows.

Key features include:

  • Multi-Agent Systems: Build collaborative agent workflows
  • MCP Workbench: Native support for Model Context Protocol tools
  • Streaming HTTP: Connect to external services through streamable HTTP
  • AssistantAgent: Pre-built agent class for tool-using assistants

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

The Zoho inventory MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Zoho Inventory account. It provides structured and secure access to your inventory management system, so your agent can perform actions like tracking stock levels, managing sales and purchase orders, updating product details, and syncing inventory across sales channels on your behalf.

  • Real-time stock tracking and updates: Let your agent monitor inventory levels, adjust quantities, and receive alerts when items are running low or out of stock.
  • Order management automation: Have the agent create, update, or track sales and purchase orders, making it easy to keep tabs on every transaction.
  • Product catalog management: Direct your agent to add new products, update existing details, or manage pricing and SKU information to keep your catalog current and accurate.
  • Multi-channel inventory syncing: Enable your agent to synchronize inventory data across multiple online stores and marketplaces, ensuring consistency and reducing errors.
  • Shipment and fulfillment handling: Empower your agent to generate shipment orders, track deliveries, and manage warehouse operations for streamlined fulfillment.

Supported Tools & Triggers

Tools
Add Credit Note CommentTool to add a comment to a credit note in Zoho Inventory.
Add Invoice AttachmentTool to upload an attachment to a specific invoice.
Add Invoice CommentTool to add a comment to a specific invoice in Zoho Inventory.
Apply Credits To InvoicesTool to apply credits from a credit note to one or more invoices.
Bulk Delete Sales OrdersTool to bulk delete sales orders.
Bulk Email InvoicesSends multiple invoices by email to a contact in a single API call.
Bulk Export InvoicesTool to bulk export invoices as a single PDF.
Bulk Print InvoicesGenerate a consolidated PDF containing multiple invoices for printing or archiving.
Bulk Print PackagesTool to bulk print package slips as a consolidated PDF.
Cancel Invoice Write OffTool to cancel write off for an invoice.
Create BillTool to create a bill in Zoho Inventory.
Create ContactTool to create a new contact (customer or vendor) in Zoho Inventory.
Create Contact PersonTool to create a contact person.
Create Credit NoteTool to create a new credit note in Zoho Inventory.
Create Customer PaymentTool to create a customer payment in Zoho Inventory.
Create InvoiceTool to create a new invoice in Zoho Inventory.
Create ItemTool to create a new item in Zoho Inventory.
Create Item GroupTool to create an item group in Zoho Inventory.
Create PackageTool to create a package for a sales order in Zoho Inventory.
Create Purchase OrderTool to create a purchase order in Zoho Inventory.
Create Sales OrderTool to create a sales order in Zoho Inventory.
Deactivate ContactTool to mark a contact as inactive in Zoho Inventory.
Deactivate ItemTool to mark an item as inactive in Zoho Inventory.
Deactivate Item GroupTool to mark an item group as inactive in Zoho Inventory.
Delete Composite ItemPermanently deletes a composite item from Zoho Inventory.
Delete ContactTool to delete a contact.
Delete Contact PersonTool to delete a contact person.
Delete InvoiceTool to delete an invoice.
Delete Invoice AttachmentTool to delete an invoice attachment.
Delete Invoice CommentDelete a specific comment from an invoice in Zoho Inventory.
Delete ItemTool to delete an item.
Delete Item GroupTool to delete an item group.
Delete Item ImageTool to delete an image associated with an item.
Delete PackageTool to delete a package.
Delete Sales OrderTool to delete a sales order.
Disable Payment ReminderTool to disable payment reminders for an invoice.
Email ContactTool to email a contact in Zoho Inventory.
Email Contact StatementTool to email a statement of transactions to a contact.
Email Credit NoteTool to email a credit note to customers.
Email InvoiceTool to email a specific invoice to customers.
Enable Invoice Payment ReminderTool to enable payment reminders for an invoice.
Get ContactTool to retrieve a specific contact by ID from Zoho Inventory.
Get Contact AddressTool to get contact address.
Get Credit NoteTool to retrieve a credit note by ID.
Get Credit Note Email ContentTool to get credit note email content including subject, body, recipients, and available templates.
Get Current UserTool to get details of the currently authenticated user in Zoho Inventory.
Get Sales OrderTool to retrieve the details of an existing sales order.
List BillsTool to list bills.
List ContactsTool to list all contacts (customers and vendors) in Zoho Inventory.
List Credit NotesTool to list all credit notes.
List CurrenciesTool to list all currencies configured in Zoho Inventory.
List Invoice PaymentsTool to list all payments received for a specific invoice.
List InvoicesTool to list all invoices in Zoho Inventory.
List Item GroupsTool to list all item groups in Zoho Inventory.
List ItemsTool to list all items in Zoho Inventory.
List OrganizationsTool to list all organizations the user has access to in Zoho Inventory.
List Purchase OrdersTool to list purchase orders.
List Sales OrdersTool to list sales orders.

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

Prerequisites

You will need:

  • A Composio API key
  • An OpenAI API key (used by Autogen's OpenAIChatCompletionClient)
  • A Zoho inventory account you can connect to Composio
  • Some basic familiarity with Autogen and Python async

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
  • Log in to the Composio dashboard.
  • Navigate to your API settings and generate a new API key.
  • Store this key securely as you'll need it for authentication.

Install dependencies

bash
pip install composio python-dotenv
pip install autogen-agentchat autogen-ext-openai autogen-ext-tools

Install Composio, Autogen extensions, and dotenv.

What's happening:

  • composio connects your agent to Zoho inventory via MCP
  • autogen-agentchat provides the AssistantAgent class
  • autogen-ext-openai provides the OpenAI model client
  • autogen-ext-tools provides MCP workbench support

Set up environment variables

bash
COMPOSIO_API_KEY=your-composio-api-key
OPENAI_API_KEY=your-openai-api-key
USER_ID=your-user-identifier@example.com

Create a .env file in your project folder.

What's happening:

  • COMPOSIO_API_KEY is required to talk to Composio
  • OPENAI_API_KEY is used by Autogen's OpenAI client
  • USER_ID is how Composio identifies which user's Zoho inventory connections to use

Import dependencies and create Tool Router session

python
import asyncio
import os
from dotenv import load_dotenv
from composio import Composio

from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import McpWorkbench, StreamableHttpServerParams

load_dotenv()

async def main():
    # Initialize Composio and create a Zoho inventory session
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))
    session = composio.create(
        user_id=os.getenv("USER_ID"),
        toolkits=["zoho_inventory"]
    )
    url = session.mcp.url
What's happening:
  • load_dotenv() reads your .env file
  • Composio(api_key=...) initializes the SDK
  • create(...) creates a Tool Router session that exposes Zoho inventory tools
  • session.mcp.url is the MCP endpoint that Autogen will connect to

Configure MCP parameters for Autogen

python
# Configure MCP server parameters for Streamable HTTP
server_params = StreamableHttpServerParams(
    url=url,
    timeout=30.0,
    sse_read_timeout=300.0,
    terminate_on_close=True,
    headers={"x-api-key": os.getenv("COMPOSIO_API_KEY")}
)

Autogen expects parameters describing how to talk to the MCP server. That is what StreamableHttpServerParams is for.

What's happening:

  • url points to the Tool Router MCP endpoint from Composio
  • timeout is the HTTP timeout for requests
  • sse_read_timeout controls how long to wait when streaming responses
  • terminate_on_close=True cleans up the MCP server process when the workbench is closed

Create the model client and agent

python
# Create model client
model_client = OpenAIChatCompletionClient(
    model="gpt-5",
    api_key=os.getenv("OPENAI_API_KEY")
)

# Use McpWorkbench as context manager
async with McpWorkbench(server_params) as workbench:
    # Create Zoho inventory assistant agent with MCP tools
    agent = AssistantAgent(
        name="zoho_inventory_assistant",
        description="An AI assistant that helps with Zoho inventory operations.",
        model_client=model_client,
        workbench=workbench,
        model_client_stream=True,
        max_tool_iterations=10
    )

What's happening:

  • OpenAIChatCompletionClient wraps the OpenAI model for Autogen
  • McpWorkbench connects the agent to the MCP tools
  • AssistantAgent is configured with the Zoho inventory tools from the workbench

Run the interactive chat loop

python
print("Chat started! Type 'exit' or 'quit' to end the conversation.\n")
print("Ask any Zoho inventory related question or task to the agent.\n")

# Conversation loop
while True:
    user_input = input("You: ").strip()

    if user_input.lower() in ["exit", "quit", "bye"]:
        print("\nGoodbye!")
        break

    if not user_input:
        continue

    print("\nAgent is thinking...\n")

    # Run the agent with streaming
    try:
        response_text = ""
        async for message in agent.run_stream(task=user_input):
            if hasattr(message, "content") and message.content:
                response_text = message.content

        # Print the final response
        if response_text:
            print(f"Agent: {response_text}\n")
        else:
            print("Agent: I encountered an issue processing your request.\n")

    except Exception as e:
        print(f"Agent: Sorry, I encountered an error: {str(e)}\n")
What's happening:
  • The script prompts you in a loop with You:
  • Autogen passes your input to the model, which decides which Zoho inventory tools to call via MCP
  • agent.run_stream(...) yields streaming messages as the agent thinks and calls tools
  • Typing exit, quit, or bye ends the loop

Complete Code

Here's the complete code to get you started with Zoho inventory and AutoGen:

python
import asyncio
import os
from dotenv import load_dotenv
from composio import Composio

from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import McpWorkbench, StreamableHttpServerParams

load_dotenv()

async def main():
    # Initialize Composio and create a Zoho inventory session
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))
    session = composio.create(
        user_id=os.getenv("USER_ID"),
        toolkits=["zoho_inventory"]
    )
    url = session.mcp.url

    # Configure MCP server parameters for Streamable HTTP
    server_params = StreamableHttpServerParams(
        url=url,
        timeout=30.0,
        sse_read_timeout=300.0,
        terminate_on_close=True,
        headers={"x-api-key": os.getenv("COMPOSIO_API_KEY")}
    )

    # Create model client
    model_client = OpenAIChatCompletionClient(
        model="gpt-5",
        api_key=os.getenv("OPENAI_API_KEY")
    )

    # Use McpWorkbench as context manager
    async with McpWorkbench(server_params) as workbench:
        # Create Zoho inventory assistant agent with MCP tools
        agent = AssistantAgent(
            name="zoho_inventory_assistant",
            description="An AI assistant that helps with Zoho inventory operations.",
            model_client=model_client,
            workbench=workbench,
            model_client_stream=True,
            max_tool_iterations=10
        )

        print("Chat started! Type 'exit' or 'quit' to end the conversation.\n")
        print("Ask any Zoho inventory related question or task to the agent.\n")

        # Conversation loop
        while True:
            user_input = input("You: ").strip()

            if user_input.lower() in ['exit', 'quit', 'bye']:
                print("\nGoodbye!")
                break

            if not user_input:
                continue

            print("\nAgent is thinking...\n")

            # Run the agent with streaming
            try:
                response_text = ""
                async for message in agent.run_stream(task=user_input):
                    if hasattr(message, 'content') and message.content:
                        response_text = message.content

                # Print the final response
                if response_text:
                    print(f"Agent: {response_text}\n")
                else:
                    print("Agent: I encountered an issue processing your request.\n")

            except Exception as e:
                print(f"Agent: Sorry, I encountered an error: {str(e)}\n")

if __name__ == "__main__":
    asyncio.run(main())

Conclusion

You now have an Autogen assistant wired into Zoho inventory through Composio's Tool Router and MCP. From here you can:
  • Add more toolkits to the toolkits list, for example notion or hubspot
  • Refine the agent description to point it at specific workflows
  • Wrap this script behind a UI, Slack bot, or internal tool
Once the pattern is clear for Zoho inventory, you can reuse the same structure for other MCP-enabled apps with minimal code changes.

How to build Zoho inventory MCP Agent with another framework

FAQ

What are the differences in Tool Router MCP and Zoho inventory MCP?

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

Can I use Tool Router MCP with Autogen?

Yes, you can. Autogen 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 Zoho inventory tools.

Can I manage the permissions and scopes for Zoho inventory while using Tool Router?

Yes, absolutely. You can configure which Zoho inventory 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.

How safe is my data with Composio Tool Router?

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 Zoho inventory data and credentials are handled as safely as possible.

Used by agents from

Context
Letta
glean
HubSpot
Agent.ai
Altera
DataStax
Entelligence
Rolai
Context
Letta
glean
HubSpot
Agent.ai
Altera
DataStax
Entelligence
Rolai
Context
Letta
glean
HubSpot
Agent.ai
Altera
DataStax
Entelligence
Rolai

Never worry about agent reliability

We handle tool reliability, observability, and security so you never have to second-guess an agent action.