Composio: AI Agent Tool Integration SDK
/composio
Composio is an SDK and CLI that hands your AI agent pre-authenticated access to over 1,000 external toolkits, so you skip writing OAuth flows and API wrappers yourself. Reach for it when your agent needs to act in third-party apps — send email, update a CRM, file a ticket — without owning the auth plumbing. Skip it if you only need a couple of tools you've already wrapped; the session model is overhead you don't need for that.
What Composio Provides for AI Agents
Composio is a toolkit-integration layer for AI agents, shipped as a TypeScript SDK (`@composio/core`), a Python SDK (`composio`), and a standalone CLI, all from one monorepo. It authenticates and exposes 1,000+ external app toolkits to an agent through per-user sessions, and hands them to whichever agent framework you're already using via provider adapters for OpenAI Agents, Claude Agent SDK, LangChain, and others listed in the README.
Core Capabilities for Agentic AI
- ✓Per-user sessions: `composio.create("user_123")` scopes tool access, auth, and connected accounts to one user, and you store `session.session_id` to reuse it across turns instead of re-authenticating.
- ✓By default, a session includes meta tools whose purpose is to discover, authenticate, and execute app tools during runtime. This arrangement ensures the agent does not receive hundreds of tool definitions initially.
- ✓Provider adapters for OpenAI, OpenAI Agents, Anthropic, Claude Agent SDK, Vercel AI SDK, Google GenAI, Google ADK, LangChain, LangGraph, LlamaIndex, Mastra, Cloudflare Workers AI, CrewAI, and AutoGen — each translates Composio's tool format into the framework's native one.
- ✓MCP endpoint per session: pass `mcp: true` to `composio.create()` and point an MCP client like Claude or Cursor at `session.mcp.url` instead of wiring a provider adapter at all.
- ✓CLI for scripting: `composio search`, `composio execute`, `composio link`, and `composio run` let you find, run, connect, and script tools straight from a terminal — useful for coding agents like Claude Code that need a local tool surface.
- ✓`@composio/slim` package: the same API as `@composio/core` without the bundled TypeScript source and SDK docs, for when you want a smaller install.
Getting Started with Composio SDKs
TypeScript: `npm install @composio/core @composio/openai-agents @openai/agents` (swap the provider package for whichever framework you use). Python: `pip install composio composio-openai-agents openai-agents`. Either way you need a `COMPOSIO_API_KEY` from the Composio dashboard before your first call. The CLI installs separately: `curl -fsSL https://composio.dev/install | sh`, then open a new terminal and run `composio login`; INSTALL.md documents shell-setup overrides like `COMPOSIO_INSTALL_SHELL=none` for install-only runs. The TypeScript SDK is tested against Node 22+, and the Python SDK supports Python 3.10+.
Integrating Tools into Your AI Agents
The pattern is the same in both SDKs: instantiate `Composio` with a provider, create a session scoped to one user (`composio.create("user_123")`), and pull that session's tools into your agent object before you run it. In the TypeScript quickstart, an OpenAI Agents `Agent` gets its `tools` from `session.tools()`, then `run(agent, "Summarize my emails from today")` executes with those toolkits already authenticated. The Python quickstart mirrors it with `Runner.run_sync`. If you don't want a provider adapter at all, set `mcp: true` on `composio.create()` and hand `session.mcp.url` to any MCP client instead.
Strengths
- ✓One session object handles discovery, authentication, and execution for 1,000+ toolkits, which cuts a lot of the per-API wrapper code a hand-rolled integration layer needs.
- ✓Meta tools mean the agent isn't loaded with hundreds of tool schemas up front — tools get discovered and authenticated at runtime instead.
- ✓Provider adapters cover a wide spread of frameworks (OpenAI Agents, Claude Agent SDK, LangChain, LangGraph, LlamaIndex, Mastra, CrewAI, AutoGen, and more), so switching frameworks doesn't necessarily mean re-plumbing tool access.
- ✓MIT-licensed, and the CLI gives coding agents a scriptable local tool surface without any provider adapter at all.
Deployment and Integration Considerations
- △You provision `COMPOSIO_API_KEY` credentials through Composio's own hosted dashboard, so the auth and session layer isn't something you can self-host or audit end-to-end from the repo alone.
- △The Pi provider ships from `@composio/experimental` and the README itself flags it as experimental — treat any framework support beyond the main list the same way until it's promoted.
- △`@composio/core` intentionally bundles its TypeScript source and SDK docs into the installed package; that's useful for a coding agent inspecting the package, but it does mean a heavier install unless you switch to `@composio/slim`.
- △Provider coverage isn't symmetric between languages — Vercel AI SDK and Mastra are TypeScript-only, while Google ADK, CrewAI, and AutoGen are Python-only, so your language choice narrows which frameworks you can adapt to directly.
Composio Alternatives for Agent Tooling
Composio Frequently Asked Questions
Composio ships an SDK monorepo with two first-class SDKs: a TypeScript package (`@composio/core`) tested against Node 22+, and a Python package (`composio`) that supports Python 3.10+.
Composio is released under the MIT license, according to the LICENSE file in the repository.
Composio supports OpenAI agents through two dedicated provider adapters, `@composio/openai` and `@composio/openai-agents` in TypeScript, plus `composio-openai` and `composio-openai-agents` in Python.
Composio includes a standalone CLI, installed with `curl -fsSL https://composio.dev/install | sh`, that runs `composio search`, `composio execute`, `composio link`, and `composio run` from a terminal.
Composio scopes each session to one user with `composio.create("user_123")`, and that session carries its own tool discovery, authentication, and connected accounts; you save `session.session_id` to reuse it across later turns.
Composio's MIT license permits commercial use, though the API key and session infrastructure run through Composio's own hosted dashboard rather than a fully self-hosted stack.
The problem it solves
Wiring an AI agent to take real action across many external apps means writing OAuth flows, storing per-user credentials, and hand-building a function-calling schema for every API you touch — repeated for each of the 1,000+ services a general-purpose agent might need to reach. Composio centralizes that authentication and tool-definition work behind one session object instead of a wrapper file per API.
Best use cases
- •A support agent that reads a user's inbox and drafts replies: create a session per user, hand its tools to an OpenAI Agents or Claude Agent SDK agent, and let it call the email toolkit directly.
- •A coding agent (Claude Code, Cursor) that needs a local shell tool surface: install the CLI and run `composio search` / `composio execute` instead of writing custom tool wrappers.
- •A multi-framework team that wants to swap agent frameworks without rewriting tool integrations: the provider adapters (LangChain, LlamaIndex, CrewAI, Mastra, and more) sit on top of the same session and toolkit layer.
- •An MCP-first workflow: point Claude, Cursor, or any MCP client at a session's `session.mcp.url` instead of building a provider adapter.
Who should try it — and who should skip
Reach for Composio if you're building an agent that needs to call multiple external services and you don't want to own OAuth and per-API tool schemas yourself — the session model and provider adapters do that work once. Skip it if your agent only touches one or two APIs you've already wrapped, or if routing authentication through Composio's hosted dashboard is a non-starter for your compliance requirements; in that case a direct integration or a self-hosted MCP server gives you more control.
Related repositories
Is composio worth your time?
ChatGPT, Claude and Perplexity can all read this page. Ask one of them what it makes of composio.