diff --git a/src/oss/javascript/integrations/tools/composio.mdx b/src/oss/javascript/integrations/tools/composio.mdx new file mode 100644 index 000000000..2ac6d7263 --- /dev/null +++ b/src/oss/javascript/integrations/tools/composio.mdx @@ -0,0 +1,527 @@ +--- +title: Composio +description: Access 500+ tools and integrations through Composio's unified API platform for AI agents, with OAuth handling, event-driven workflows, and multi-user support. +--- + +[Composio](https://composio.dev) is an integration platform that provides access to 500+ tools across popular applications like GitHub, Slack, Notion, and more. It enables AI agents to interact with external services through a unified API, handling authentication, permissions, and event-driven workflows. + +## Overview + +### Integration details + +| Class | Package | Serializable | [Python support](/oss/integrations/tools/composio) | Version | +|:---|:---|:---:|:---:|:---:| +| Composio | [@composio/langchain](https://www.npmjs.com/package/@composio/langchain) | ❌ | ✅ | ![npm version](https://img.shields.io/npm/v/@composio/langchain?style=flat-square&label=%20) | + +### Tool features + +- **500+ Tool Access**: Pre-built integrations for GitHub, Slack, Gmail, Jira, Notion, and more +- **Authentication Management**: Handles OAuth flows, API keys, and authentication state +- **Event-Driven Workflows**: Trigger agents based on external events (new Slack messages, GitHub issues, etc.) +- **Fine-Grained Permissions**: Control tool access and data exposure per user +- **Custom Tool Support**: Add proprietary APIs and internal tools + +## Setup + +The integration lives in the `@composio/langchain` package. + +```bash +npm install @composio/langchain @composio/core +``` + +Or using other package managers: + +```bash +yarn add @composio/langchain @composio/core +# or +pnpm add @composio/langchain @composio/core +``` + +### Credentials + +You'll need a Composio API key. Sign up for free at [composio.dev](https://composio.dev) to get your API key. + +```typescript Set API key +import * as dotenv from 'dotenv'; +dotenv.config(); + +// Set your Composio API key +process.env.COMPOSIO_API_KEY = 'your_api_key_here'; +``` + +It's also helpful to set up [LangSmith](https://docs.smith.langchain.com/) for tracing: + +```typescript Enable tracing +// process.env.LANGSMITH_API_KEY = 'your_langsmith_key'; +// process.env.LANGSMITH_TRACING = 'true'; +``` + +## Instantiation + +Initialize Composio with the LangChain provider and get tools from specific toolkits. Each toolkit represents a service (e.g., GitHub, Slack) with multiple tools (actions you can perform). + +```typescript Initialize Composio +import { Composio } from '@composio/core'; +import { LangchainProvider } from '@composio/langchain'; + +// Initialize Composio with LangChain provider +const composio = new Composio({ + apiKey: process.env.COMPOSIO_API_KEY, + provider: new LangchainProvider(), +}); + +// Get tools from specific toolkits +const tools = await composio.tools.get('default', 'GITHUB'); + +console.log(`Loaded ${tools.length} tools from GitHub toolkit`); +``` + +### Available toolkits + +Composio provides toolkits for various services: + +**Productivity**: GitHub, Slack, Gmail, Jira, Notion, Asana, Trello, ClickUp +**Communication**: Discord, Telegram, WhatsApp, Microsoft Teams +**Development**: GitLab, Bitbucket, Linear, Sentry +**Data & Analytics**: Google Sheets, Airtable, HubSpot, Salesforce +**And 100+ more...** + +## Invocation + +### Get tools from multiple toolkits + +You can load tools from multiple services: + +```typescript +// Get tools from multiple toolkits +const tools = await composio.tools.get('default', ['GITHUB', 'SLACK', 'GMAIL']); +``` + +### Get specific tools + +Instead of entire toolkits, you can load specific tools: + +```typescript +// Get specific tools by name +const tools = await composio.tools.get('default', { + tools: ['GITHUB_CREATE_ISSUE', 'SLACK_SEND_MESSAGE'] +}); +``` + +### User-specific tools + +Composio supports multi-user scenarios with user-specific authentication: + +```typescript +// Get tools for a specific user +// This user must have authenticated their accounts first +const tools = await composio.tools.get('user_123', 'GITHUB'); +``` + +## Use within an agent + +Here's a complete example using Composio tools with a LangGraph agent to interact with HackerNews: + +```typescript +import { ChatOpenAI } from '@langchain/openai'; +import { HumanMessage, AIMessage } from '@langchain/core/messages'; +import { ToolNode } from '@langchain/langgraph/prebuilt'; +import { StateGraph, MessagesAnnotation } from '@langchain/langgraph'; +import { Composio } from '@composio/core'; +import { LangchainProvider } from '@composio/langchain'; + +// Initialize Composio +const composio = new Composio({ + apiKey: process.env.COMPOSIO_API_KEY, + provider: new LangchainProvider(), +}); + +// Fetch the tools +console.log('🔄 Fetching the tools...'); +const tools = await composio.tools.get('default', 'HACKERNEWS_GET_USER'); + +// Define the tools for the agent to use +const toolNode = new ToolNode(tools); + +// Create a model and give it access to the tools +const model = new ChatOpenAI({ + model: 'gpt-5', +}).bindTools(tools); + +// Define the function that determines whether to continue or not +function shouldContinue({ messages }: typeof MessagesAnnotation.State) { + const lastMessage = messages[messages.length - 1] as AIMessage; + + // If the LLM makes a tool call, then we route to the "tools" node + if (lastMessage.tool_calls?.length) { + return 'tools'; + } + + // Otherwise, we stop (reply to the user) + return '__end__'; +} + +// Define the function that calls the model +async function callModel(state: typeof MessagesAnnotation.State) { + console.log('🔄 Calling the model...'); + const response = await model.invoke(state.messages); + return { messages: [response] }; +} + +// Define a new graph +const workflow = new StateGraph(MessagesAnnotation) + .addNode('agent', callModel) + .addEdge('__start__', 'agent') + .addNode('tools', toolNode) + .addEdge('tools', 'agent') + .addConditionalEdges('agent', shouldContinue); + +// Compile the graph +const app = workflow.compile(); + +// Use the agent +const finalState = await app.invoke({ + messages: [new HumanMessage('Find the details of the user `pg` on HackerNews')] +}); + +console.log('✅ Message received from the model'); +console.log(finalState.messages[finalState.messages.length - 1].content); + +// Continue the conversation +const nextState = await app.invoke({ + messages: [...finalState.messages, new HumanMessage('what about haxzie')] +}); + +console.log('✅ Message received from the model'); +console.log(nextState.messages[nextState.messages.length - 1].content); +``` + +### Using with GitHub toolkit + +Here's an example that stars a GitHub repository: + +```typescript +import { ChatOpenAI } from '@langchain/openai'; +import { createReactAgent } from '@langchain/langgraph/prebuilt'; +import { Composio } from '@composio/core'; +import { LangchainProvider } from '@composio/langchain'; + +// Initialize Composio +const composio = new Composio({ + apiKey: process.env.COMPOSIO_API_KEY, + provider: new LangchainProvider(), +}); + +// Get GitHub tools +const tools = await composio.tools.get('default', 'GITHUB'); + +// Create model +const model = new ChatOpenAI({ + model: 'gpt-5', +}); + +// Create agent +const agent = createReactAgent({ + llm: model, + tools: tools, +}); + +// Execute task +const result = await agent.invoke({ + messages: [ + { + role: 'user', + content: 'Star the repository composiohq/composio on GitHub' + } + ] +}); + +console.log(result.messages[result.messages.length - 1].content); +``` + +## Authentication setup + +Before using tools that require authentication, users need to connect their accounts: + +```typescript +import { Composio } from '@composio/core'; + +const composio = new Composio({ + apiKey: process.env.COMPOSIO_API_KEY +}); + +// Get authentication URL for a user +const authConnection = await composio.integrations.create({ + userId: 'user_123', + integration: 'github' +}); + +console.log(`Authenticate at: ${authConnection.redirectUrl}`); + +// After authentication, the user's connected account will be available +// and tools will work with their credentials +``` + +## Multi-user scenarios + +For applications with multiple users: + +```typescript +// Each user authenticates their own accounts +const toolsUser1 = await composio.tools.get('user_1', 'GITHUB'); +const toolsUser2 = await composio.tools.get('user_2', 'GITHUB'); + +// Tools will use the respective user's credentials +// User 1's agent will act on User 1's GitHub account +const agent1 = createAgent(model, toolsUser1); + +// User 2's agent will act on User 2's GitHub account +const agent2 = createAgent(model, toolsUser2); +``` + +## Event-driven workflows + +Composio supports triggering agents based on external events. When events occur in connected apps (like new GitHub commits or Slack messages), triggers automatically send structured payloads to your application. + +### Creating a trigger + +First, create a trigger for the events you want to monitor: + +```typescript +import { Composio } from '@composio/core'; + +const composio = new Composio({ apiKey: 'your_api_key' }); +const userId = 'user_123'; + +// Check what configuration is required for the trigger +const triggerType = await composio.triggers.getType('GITHUB_COMMIT_EVENT'); +console.log(triggerType.config); + +// Create trigger with required configuration +const trigger = await composio.triggers.create( + userId, + 'GITHUB_COMMIT_EVENT', + { + triggerConfig: { + owner: 'composiohq', + repo: 'composio' + } + } +); + +console.log(`Trigger created: ${trigger.triggerId}`); +``` + +### Subscribing to triggers (Development) + +For local development and prototyping, you can subscribe directly to triggers: + +```typescript +import { Composio } from '@composio/core'; + +const composio = new Composio({ apiKey: 'your_api_key' }); + +// Subscribe to trigger events +composio.triggers.subscribe( + (data) => { + console.log(`New commit detected:`, data); + // Process the event with your agent + // ... invoke your agent with the task + }, + { + triggerId: 'your_trigger_id', + // You can also filter by: + // userId: 'user@acme.com', + // toolkits: ['github', 'slack'], + // triggerSlug: ["GITHUB_COMMIT_EVENT"], + // authConfigId: "ac_1234567890" + } +); + +// Note: For production, use webhooks instead +``` + +### Type-safe trigger handling + +For better type safety, define payload types: + +```typescript +import { TriggerEvent } from '@composio/core'; + +// Define type-safe payload +export type GitHubStarAddedEventPayload = { + action: 'created'; + repository_id: number; + repository_name: string; + repository_url: string; + starred_at: string; + starred_by: string; +}; + +// Type-safe handler +function handleGitHubStarAddedEvent(event: TriggerEvent) { + console.log(`⭐ ${event.data.repository_name} starred by ${event.data.starred_by}`); +} +``` + +### Webhooks (Production) + +For production, configure webhooks in the [Composio dashboard](https://platform.composio.dev/settings/events): + +```typescript +import type { NextApiRequest, NextApiResponse } from 'next'; + +export default async function handler(req: NextApiRequest, res: NextApiResponse) { + if (req.method !== 'POST') { + return res.status(405).json({ error: 'Method not allowed' }); + } + + try { + const payload = req.body; + + console.log('Received trigger event:', payload); + + // Process the event with your agent + if (payload.triggerSlug === 'GITHUB_COMMIT_EVENT') { + const commitData = payload.payload; + // ... invoke your agent with commitData + } + + res.status(200).json({ status: 'success' }); + } catch (error) { + console.error('Error processing webhook:', error); + res.status(500).json({ error: 'Internal server error' }); + } +} +``` + +For more details, see the [Composio Triggers documentation](https://docs.composio.dev/docs/using-triggers) + +## Advanced features + +### Custom tools + +Composio allows you to create custom tools that can be used alongside built-in tools. There are two types: + +#### Standalone tools + +Simple tools that don't require authentication: + +```typescript +import { Composio } from '@composio/core'; +import { z } from 'zod'; + +const composio = new Composio({ + apiKey: process.env.COMPOSIO_API_KEY +}); + +const tool = await composio.tools.createCustomTool({ + slug: 'CALCULATE_SQUARE', + name: 'Calculate Square', + description: 'Calculates the square of a number', + inputParams: z.object({ + number: z.number().describe('The number to calculate the square of'), + }), + execute: async input => { + const { number } = input; + return { + data: { result: number * number }, + error: null, + successful: true, + }; + }, +}); + +// Use with your agent +const allTools = [...tools, tool]; +``` + +#### Toolkit-based tools + +Tools that require authentication and can use toolkit credentials: + +```typescript +import { Composio } from '@composio/core'; +import { z } from 'zod'; + +const composio = new Composio({ + apiKey: process.env.COMPOSIO_API_KEY +}); + +const tool = await composio.tools.createCustomTool({ + slug: 'GITHUB_STAR_COMPOSIOHQ_REPOSITORY', + name: 'Github star composio repositories', + toolkitSlug: 'github', + description: 'Star any specified repo of `composiohq` user', + inputParams: z.object({ + repository: z.string().describe('The repository to star'), + page: z.number().optional().describe('Pagination page number'), + customHeader: z.string().optional().describe('Custom header'), + }), + execute: async (input, connectionConfig, executeToolRequest) => { + // This method makes authenticated requests to the relevant API + // Composio will automatically inject the baseURL + const result = await executeToolRequest({ + endpoint: `/user/starred/composiohq/${input.repository}`, + method: 'PUT', + body: {}, + // Add custom headers or query parameters + parameters: [ + // Add query parameters + { + name: 'page', + value: input.page?.toString() || '1', + in: 'query', + }, + // Add custom headers + { + name: 'x-custom-header', + value: input.customHeader || 'default-value', + in: 'header', + }, + ], + }); + return result; + }, +}); +``` + +Execute custom tools: + +```typescript +import { Composio } from '@composio/core'; + +const composio = new Composio({ + apiKey: process.env.COMPOSIO_API_KEY +}); + +const result = await composio.tools.execute('TOOL_SLUG', { + arguments: { + // Tool input parameters + }, + userId: 'user-id', + connectedAccountId: 'optional-account-id', // Required for toolkit-based tools +}); +``` + +For more details, see the [Composio Custom Tools documentation](https://docs.composio.dev/docs/custom-tools) + +### Fine-grained permissions + +Control what actions tools can perform: + +```typescript +// Get tools with specific permissions +const tools = await composio.tools.get('default', 'GITHUB', { + // Limit to read-only operations + permissions: ['read'] +}); +``` + +## API reference + +For detailed documentation of all Composio features and configurations, visit: +- [Composio Documentation](https://docs.composio.dev) +- [LangChain Provider Guide](https://docs.composio.dev/providers/langchain) +- [Available Tools & Actions](https://docs.composio.dev/toolkits/introduction) + diff --git a/src/oss/javascript/integrations/tools/index.mdx b/src/oss/javascript/integrations/tools/index.mdx index 56efb896a..39ab5799a 100644 --- a/src/oss/javascript/integrations/tools/index.mdx +++ b/src/oss/javascript/integrations/tools/index.mdx @@ -6,6 +6,14 @@ title: Tools and Toolkits A [toolkit](/oss/langchain/tools#toolkits) is a collection of tools meant to be used together. +## Integration Platforms + +The following platforms provide access to multiple tools and services through a unified interface: + +| Tool/Toolkit | Number of Integrations | Pricing | Key Features | +|-------------|----------------------|---------|--------------| +| [Composio](/oss/integrations/tools/composio) | 500+ | Free tier available | OAuth handling, event-driven workflows, multi-user support | + ## All Tools and Toolkits @@ -23,6 +31,13 @@ A [toolkit](/oss/langchain/tools#toolkits) is a collection of tools meant to be arrow="true" cta="View guide" /> + +```python pip +pip install -U composio-langchain +``` +```python uv +uv add composio-langchain +``` + + +### Credentials + +You'll need a Composio API key. Sign up for free at [composio.dev](https://composio.dev) to get your API key. + +```python Set API key icon="key" +import getpass +import os + +if not os.environ.get("COMPOSIO_API_KEY"): + os.environ["COMPOSIO_API_KEY"] = getpass.getpass("Enter your Composio API key: ") +``` + +It's also helpful to set up [LangSmith](https://docs.smith.langchain.com/) for tracing: + +```python Enable tracing icon="flask" +# os.environ["LANGSMITH_API_KEY"] = getpass.getpass("Enter your LangSmith API key: ") +# os.environ["LANGSMITH_TRACING"] = "true" +``` + +## Instantiation + +Initialize Composio with the LangChain provider and get tools from specific toolkits. Each toolkit represents a service (e.g., GitHub, Slack) with multiple tools (actions you can perform). + +```python Initialize Composio icon="robot" +from composio import Composio +from composio_langchain import LangchainProvider + +# Initialize Composio with LangChain provider +composio = Composio(provider=LangchainProvider()) + +# Get tools from specific toolkits +# You can specify one or more toolkits +tools = composio.tools.get( + user_id="default", + toolkits=["GITHUB"] +) + +print(f"Loaded {len(tools)} tools from GitHub toolkit") +``` + +### Available toolkits + +Composio provides toolkits for various services: + +**Productivity**: GitHub, Slack, Gmail, Jira, Notion, Asana, Trello, ClickUp +**Communication**: Discord, Telegram, WhatsApp, Microsoft Teams +**Development**: GitLab, Bitbucket, Linear, Sentry +**Data & Analytics**: Google Sheets, Airtable, HubSpot, Salesforce +**And 100+ more...** + +## Invocation + +### Get tools from multiple toolkits + +You can load tools from multiple services at once: + +```python +# Get tools from multiple toolkits +tools = composio.tools.get( + user_id="default", + toolkits=["GITHUB", "SLACK", "GMAIL"] +) +``` + +### Get specific tools + +Instead of entire toolkits, you can load specific tools: + +```python +# Get specific tools by name +tools = composio.tools.get( + user_id="default", + tools=["GITHUB_CREATE_ISSUE", "SLACK_SEND_MESSAGE"] +) +``` + +### User-specific tools + +Composio supports multi-user scenarios with user-specific authentication: + +```python +# Get tools for a specific user +# This user must have authenticated their accounts first +tools = composio.tools.get( + user_id="user_123", + toolkits=["GITHUB"] +) +``` + +## Use within an agent + +Here's a complete example using Composio tools with a LangChain agent to interact with GitHub: + + + +```python +import os +import getpass + +if not os.environ.get("OPENAI_API_KEY"): + os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter your OpenAI API key: ") +``` + +```python +# | output: false +# | echo: false + +from langchain.chat_models import init_chat_model + +llm = init_chat_model(model="gpt-5", model_provider="openai") +``` + +```python Agent with Composio tools icon="robot" +from composio import Composio +from composio_langchain import LangchainProvider +from langchain import hub +from langchain.agents import AgentExecutor, create_openai_functions_agent + +# Pull the prompt template +prompt = hub.pull("hwchase17/openai-functions-agent") + +# Initialize Composio +composio = Composio(provider=LangchainProvider()) + +# Get GitHub tools +tools = composio.tools.get(user_id="default", toolkits=["GITHUB"]) + +# Define task +task = "Star a repo composiohq/composio on GitHub" + +# Create agent +agent = create_openai_functions_agent(llm, tools, prompt) +agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) + +# Execute using agent_executor +agent_executor.invoke({"input": task}) +``` + +### Event-driven workflows + +Composio supports triggering agents based on external events. When events occur in connected apps (like new GitHub commits or Slack messages), triggers automatically send structured payloads to your application. + +#### Creating a trigger + +First, create a trigger for the events you want to monitor: + +```python +from composio import Composio + +composio = Composio(api_key="your_api_key") +user_id = "user_123" + +# Check what configuration is required for the trigger +trigger_type = composio.triggers.get_type("GITHUB_COMMIT_EVENT") +print(trigger_type.config) + +# Create trigger with required configuration +trigger = composio.triggers.create( + slug="GITHUB_COMMIT_EVENT", + user_id=user_id, + trigger_config={ + "owner": "composiohq", + "repo": "composio" + } +) + +print(f"Trigger created: {trigger.trigger_id}") +``` + +#### Subscribing to triggers (Development) + +For local development and prototyping, you can subscribe directly to triggers: + +```python +from composio import Composio + +composio = Composio(api_key="your_api_key") + +# Subscribe to trigger events +subscription = composio.triggers.subscribe() + +# Define event handler +@subscription.handle(trigger_id="your_trigger_id") +def handle_github_commit(data): + print(f"New commit detected: {data}") + # Process the event with your agent + # ... invoke your agent with the task + +# Note: For production, use webhooks instead +``` + +#### Webhooks (Production) + +For production, configure webhooks in the [Composio dashboard](https://platform.composio.dev/settings/events): + +```python +from fastapi import FastAPI, Request +import json + +app = FastAPI() + +@app.post("/webhook") +async def webhook_handler(request: Request): + # Get the webhook payload + payload = await request.json() + + print("Received trigger event:") + print(json.dumps(payload, indent=2)) + + # Process the event with your agent + if payload.get("triggerSlug") == "GITHUB_COMMIT_EVENT": + commit_data = payload.get("payload") + # ... invoke your agent with commit_data + + return {"status": "success"} +``` + +For more details, see the [Composio Triggers documentation](https://docs.composio.dev/docs/using-triggers) + +## Authentication setup + +Before using tools that require authentication, users need to connect their accounts: + +```python +from composio import Composio + +composio = Composio() + +# Get authentication URL for a user +auth_connection = composio.integrations.create( + user_id="user_123", + integration="github" +) + +print(f"Authenticate at: {auth_connection.redirect_url}") + +# After authentication, the user's connected account will be available +# and tools will work with their credentials +``` + +## Multi-user scenarios + +For applications with multiple users: + +```python +# Each user authenticates their own accounts +tools_user_1 = composio.tools.get(user_id="user_1", toolkits=["GITHUB"]) +tools_user_2 = composio.tools.get(user_id="user_2", toolkits=["GITHUB"]) + +# Tools will use the respective user's credentials +# User 1's agent will act on User 1's GitHub account +agent_1 = create_agent(llm, tools_user_1) + +# User 2's agent will act on User 2's GitHub account +agent_2 = create_agent(llm, tools_user_2) +``` + +## Advanced features + +### Custom tools + +Composio allows you to create custom tools that can be used alongside built-in tools. There are two types: + +#### Standalone tools + +Simple tools that don't require authentication: + +```python +from pydantic import BaseModel, Field +from composio import Composio + +composio = Composio() + +class AddTwoNumbersInput(BaseModel): + a: int = Field(..., description="The first number to add") + b: int = Field(..., description="The second number to add") + +# Function name will be used as the tool slug +@composio.tools.custom_tool +def add_two_numbers(request: AddTwoNumbersInput) -> int: + """Add two numbers.""" + return request.a + request.b + +# Use with your agent +tools = composio.tools.get(user_id="default", toolkits=["GITHUB"]) +tools.append(add_two_numbers) +``` + +#### Toolkit-based tools + +Tools that require authentication and can use toolkit credentials: + +```python +from composio.types import ExecuteRequestFn + +class GetIssueInfoInput(BaseModel): + issue_number: int = Field( + ..., description="The number of the issue to get information about" + ) + +@composio.tools.custom_tool(toolkit="github") +def get_issue_info( + request: GetIssueInfoInput, + execute_request: ExecuteRequestFn, + auth_credentials: dict, +) -> dict: + """Get information about a GitHub issue.""" + response = execute_request( + endpoint=f"/repos/composiohq/composio/issues/{request.issue_number}", + method="GET", + parameters=[ + { + "name": "Accept", + "value": "application/vnd.github.v3+json", + "type": "header", + }, + { + "name": "Authorization", + "value": f"Bearer {auth_credentials['access_token']}", + "type": "header", + }, + ], + ) + return {"data": response.data} +``` + +Execute custom tools: + +```python +response = composio.tools.execute( + user_id="default", + slug="get_issue_info", # Use function name as slug + arguments={"issue_number": 1}, +) +``` + +For more details, see the [Composio Custom Tools documentation](https://docs.composio.dev/docs/custom-tools) + +### Fine-grained permissions + +Control what actions tools can perform: + +```python +# Get tools with specific permissions +tools = composio.tools.get( + user_id="default", + toolkits=["GITHUB"], + # Limit to read-only operations + permissions=["read"] +) +``` + +## API reference + +For detailed documentation of all Composio features and configurations, visit: +- [Composio Documentation](https://docs.composio.dev) +- [LangChain Provider Guide](https://docs.composio.dev/providers/langchain) +- [Available Tools & Actions](https://docs.composio.dev/toolkits/introduction) + diff --git a/src/oss/python/integrations/tools/index.mdx b/src/oss/python/integrations/tools/index.mdx index fecfcae0a..fd82fac87 100644 --- a/src/oss/python/integrations/tools/index.mdx +++ b/src/oss/python/integrations/tools/index.mdx @@ -84,6 +84,14 @@ The following table shows tools that can be used to execute financial transactio |-------------|---------|--------------| | [GOAT](/oss/integrations/tools/goat) | Free | Create and receive payments, purchase physical goods, make investments, and more. | +## Integration Platforms + +The following platforms provide access to multiple tools and services through a unified interface: + +| Tool/Toolkit | Number of Integrations | Pricing | Key Features | +|-------------|----------------------|---------|--------------| +| [Composio](/oss/integrations/tools/composio) | 500+ | Free tier available | OAuth handling, event-driven workflows, multi-user support | + ## All tools and toolkits @@ -114,6 +122,7 @@ The following table shows tools that can be used to execute financial transactio +