Composio

Composio provides provider packages (@composio/langchain, @composio/crewai, @composio/openai_agents, etc.) that translate 500+ pre-built toolkit actions into framework-native tool definitions. Each provider package wraps the core Composio SDK and exposes tools as LangChain ToolCollection, CrewAI Tool objects, or OpenAI function schemas, enabling agents to discover and invoke external service actions without framework-specific reimplementation. The system uses OpenAPI-based schemas stored in the tool registry to generate consistent tool definitions across all frameworks.

Composio manages user sessions that bind authenticated credentials to specific tool invocations. When an agent executes a tool action, the session router automatically retrieves the correct OAuth token, API key, or custom auth credential from the credential store and injects it into the API request. Sessions are created per user/workspace and persist across multiple tool calls, eliminating the need for agents to manage authentication state. The system supports OAuth 2.0, API keys, custom auth flows, and credential refresh without agent intervention.

Composio executes toolkit actions through a unified execution engine that validates inputs against OpenAPI schemas, executes the action via the target service API, and validates outputs before returning to the agent. The execution engine is framework-agnostic, meaning the same tool execution logic works across LangChain, CrewAI, AutoGen, and direct SDK calls. Output validation ensures agents receive well-formed results, reducing downstream errors and enabling type-safe tool result handling.

Composio manages toolkit versions using a changesets-based system that tracks semantic versioning, breaking changes, and deprecations. Agents can pin to specific toolkit versions, and the system provides migration guides for breaking changes. Version metadata includes deprecation notices, feature additions, and bug fixes, enabling developers to make informed decisions about upgrading. The monorepo structure ensures all provider packages (TypeScript, Python, LangChain, CrewAI) receive synchronized version updates.

Composio uses a monorepo structure (pnpm workspaces) that manages TypeScript SDK (@composio/core, provider packages), Python SDK (composio, provider packages), CLI, and documentation as interdependent packages. A changesets-based release system ensures synchronized version bumps across all packages, preventing version skew between core SDK and provider packages. The monorepo enables atomic updates where a single toolkit change is released simultaneously across all languages and frameworks.

Composio's trigger engine enables agents to subscribe to real-time events from external services (e.g., GitHub push events, Slack messages, Jira issue updates) through a unified webhook and WebSocket interface. The system registers webhooks with target services, normalizes incoming events into a standard schema, and broadcasts them to subscribed agents via WebSocket (Pusher) or HTTP callbacks. Agents can define trigger handlers that automatically execute actions when specific events occur, enabling reactive workflows without polling.

Composio abstracts file operations through a unified file service that handles upload/download to S3 with presigned URLs, eliminating the need for agents to manage file storage directly. When an agent needs to upload a file (e.g., to GitHub, Slack, or Jira), Composio generates a presigned S3 URL, uploads the file, and passes the S3 reference to the target service API. For downloads, Composio retrieves files from external services and stores them in S3, providing agents with a consistent file interface regardless of the underlying service.

Composio maintains a centralized tool registry of 500+ pre-built toolkits, each defined as OpenAPI schemas. The system automatically generates tool definitions from OpenAPI specs, handles schema versioning, and distributes toolkit updates across all provider packages (TypeScript, Python, LangChain, CrewAI, etc.) without requiring agent code changes. Toolkit versions are managed through a changesets-based system, enabling semantic versioning and backward compatibility tracking.

Composio enables developers to define custom tools beyond the 500+ pre-built toolkits using a modifier system that wraps existing toolkit actions or creates entirely new tools. Custom tools are defined as OpenAPI schemas and integrated into the tool registry, making them available across all frameworks and sessions. Modifiers can transform tool inputs/outputs, add validation logic, or chain multiple toolkit actions into composite operations, all without modifying core Composio code.

Composio provides an MCP server at mcp.composio.dev that exposes all 500+ toolkit actions as MCP resources and tools, enabling Claude and other MCP-compatible agents to discover and invoke Composio tools through the standard MCP protocol. The hosted MCP endpoint handles authentication, session management, and tool routing transparently, allowing agents to treat Composio toolkits as native MCP resources without SDK integration.

Composio provides parallel TypeScript (@composio/core, provider packages) and Python (composio, provider packages) SDKs with feature parity, enabling developers to build agents in their preferred language. Both SDKs share the same underlying architecture (tool registry, session management, authentication) but expose language-native APIs (TypeScript: async/await, decorators; Python: async/sync, context managers). The monorepo structure ensures synchronized updates across both language implementations.

Composio provides a CLI (@composio/cli) that enables developers to discover available toolkits, test tool actions locally, and manage authentication without writing code. The CLI includes commands for listing toolkits, inspecting tool schemas, executing tools with test parameters, and managing connected accounts. It supports both binary distribution (for non-Node.js environments) and npm installation, making it accessible to developers regardless of their primary language.

Composio implements rate limiting and error handling at the tool router layer, automatically managing API quotas for external services and retrying failed requests with exponential backoff. The system tracks rate limits per service and per session, queuing requests when limits are approached and retrying transient failures (5xx errors, timeouts) without agent intervention. Error responses include retry metadata (backoff duration, retry count) enabling agents to make informed decisions about request prioritization.