MCP (Model Control Protocol) & Experimental ToolRouter

// @noErrors
import { Composio } from '@composio/core';

const composio = new Composio({
  apiKey: process.env.COMPOSIO_API_KEY,
});

// Create MCP configuration
const mcpConfig = await composio.mcp.create('my-server-name', {
  toolkits: [
    { toolkit: 'github', authConfigId: 'ac_233434343' },
    { toolkit: 'gmail', authConfigId: 'ac_567890123' }
  ],
  allowedTools: ['GITHUB_CREATE_ISSUE', 'GMAIL_SEND_EMAIL'],
  manuallyManageConnections: false,
});

// Generate server instance for a user
const serverInstance = await composio.mcp.generate('user123', mcpConfig.id);
console.log('MCP URL:', serverInstance.url);

// @noErrors
// Vercel AI Integration
import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
import { experimental_createMCPClient as createMCPClient } from 'ai';

const mcpClient = await createMCPClient({
  name: 'composio-mcp-client',
  transport: new SSEClientTransport(new URL(serverInstance.url)),
});

// Mastra Integration
import { MCPClient as MastraMCPClient } from '@mastra/mcp';

const mcpClient = new MastraMCPClient({
  servers: {
    composio: { url: new URL(mcpSession.url) },
  },
});

// OpenAI Agents Integration
import { hostedMcpTool } from '@openai/agents';

const tools = [
  hostedMcpTool({
    serverLabel: 'composio',
    serverUrl: mcpSession.url,
  }),
];

// @noErrors
// Create session with simple toolkit names
const session = await composio.experimental.toolRouter.createSession('user_123', {
  toolkits: ['gmail', 'slack', 'github'],
});

// Create session with auth configs
const session = await composio.experimental.toolRouter.createSession('user_456', {
  toolkits: [
    { toolkit: 'gmail', authConfigId: 'ac_gmail_work' },
    { toolkit: 'slack', authConfigId: 'ac_slack_team' },
    { toolkit: 'github', authConfigId: 'ac_github_personal' },
  ],
  manuallyManageConnections: true,
});

console.log('Session ID:', session.sessionId);
console.log('MCP URL:', session.url);

// @noErrors
// Complex workflow session
const integrationSession = await composio.experimental.toolRouter.createSession('user_789', {
  toolkits: [
    { toolkit: 'gmail', authConfigId: 'ac_gmail_work' },
    { toolkit: 'slack', authConfigId: 'ac_slack_team' },
    { toolkit: 'github', authConfigId: 'ac_github_personal' },
    { toolkit: 'notion', authConfigId: 'ac_notion_workspace' },
    { toolkit: 'calendar', authConfigId: 'ac_gcal_primary' },
  ],
});

// Use with any MCP client
const mcpClient = new MCPClient(integrationSession.url);

// @noErrors
// Mastra Integration
const mcpSession = await composio.experimental.toolRouter.createSession(userId, {
  toolkits: ["gmail"],
  manuallyManageConnections: true,
});

const agent = new MastraAgent({
  name: 'Gmail Assistant',
  model: openai('gpt-4o-mini'),
  tools: await mcpClient.getTools(),
});

// OpenAI Agents Integration
const tools = [
  hostedMcpTool({
    serverLabel: 'composio tool router',
    serverUrl: mcpSession.url,
    requireApproval: {
      never: { toolNames: ['GMAIL_FETCH_EMAILS'] },
    },
  }),
];

from composio import Composio

composio = Composio()

# Create MCP server with toolkit configurations
server = composio.mcp.create(
    'personal-mcp-server',
    toolkits=[
        {
            'toolkit': 'github',
            'auth_config_id': 'ac_xyz',
        },
        {
            'toolkit': 'slack',
            'auth_config_id': 'ac_abc',
        },
    ],
    allowed_tools=['GITHUB_CREATE_ISSUE', 'SLACK_SEND_MESSAGE'],
    manually_manage_connections=False
)

# Generate server instance for a user
mcp_instance = server.generate('user_12345')
print(f"MCP URL: {mcp_instance['url']}")

# Using simple toolkit names
server = composio.mcp.create(
    'simple-mcp-server',
    toolkits=['composio_search', 'text_to_pdf'],
    allowed_tools=['COMPOSIO_SEARCH_DUCK_DUCK_GO_SEARCH', 'TEXT_TO_PDF_CONVERT_TEXT_TO_PDF']
)

# All tools from toolkits (default behavior)
server = composio.mcp.create(
    'all-tools-server',
    toolkits=['composio_search', 'text_to_pdf']
    # allowed_tools=None means all tools from these toolkits
)

import asyncio
from composio import Composio
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent

composio = Composio()

mcp_config = composio.mcp.create(
    name="langchain-slack-mcp",
    toolkits=[{"toolkit": "slack", "auth_config_id": "<auth-config-id>"}],
)

mcp_server = mcp_config.generate(user_id='<user-id>')

client = MultiServerMCPClient({
    "composio": {
        "url": mcp_server["url"],
        "transport": "streamable_http",
    }
})

async def langchain_mcp(message: str):
    tools = await client.get_tools()
    agent = create_react_agent("openai:gpt-4.1", tools)
    response = await agent.ainvoke({"messages": message})
    return response

response = asyncio.run(langchain_mcp("Show me 20 most used slack channels"))

from composio import Composio

composio = Composio()

# Create a tool router session
session = composio.experimental.tool_router.create_session(
    user_id='user_123',
    toolkits=['github', 'slack'],
    manually_manage_connections=False
)

print(f"Session ID: {session['session_id']}")
print(f"MCP URL: {session['url']}")

# Create session with detailed toolkit configurations
session = composio.experimental.tool_router.create_session(
    user_id='user_456',
    toolkits=[
        {
            'toolkit': 'github',
            'auth_config_id': 'ac_github_123'
        },
        {
            'toolkit': 'slack',
            'auth_config_id': 'ac_slack_456'
        }
    ],
    manually_manage_connections=True
)

# Minimal session (no specific toolkits)
session = composio.experimental.tool_router.create_session(
    user_id='user_789'
)

import asyncio
from composio import Composio
from langchain_mcp_adapters.client import MultiServerMCPClient

composio = Composio()

# Create tool router session
session = composio.experimental.tool_router.create_session(
    user_id='ai_user',
    toolkits=['composio_search', 'text_to_pdf']
)

# Use with LangChain MCP client
client = MultiServerMCPClient({
    "composio": {
        "url": session["url"],
        "transport": "streamable_http",
    }
})

async def use_tool_router():
    tools = await client.get_tools()
    # Use tools in your AI workflow
    return tools

tools = asyncio.run(use_tool_router())

// @noErrors
// Legacy MCP approach (still accessible via deprecated.mcp)
import { Composio } from '@composio/core';

const composio = new Composio();

// Old MCP server creation
const legacyMCP = await composio.deprecated.mcp.createServer({
  name: 'my-server',
  toolkits: ['github', 'gmail'],
});

// Direct URL usage
const mcpUrl = legacyMCP.url;

// @noErrors
// New MCP API approach
import { Composio } from '@composio/core';

const composio = new Composio({
  apiKey: process.env.COMPOSIO_API_KEY,
});

// Step 1: Create MCP configuration
const mcpConfig = await composio.mcp.create('my-server', {
  toolkits: [
    { toolkit: 'github', authConfigId: 'ac_github_123' },
    { toolkit: 'gmail', authConfigId: 'ac_gmail_456' }
  ],
  allowedTools: ['GITHUB_CREATE_ISSUE', 'GMAIL_SEND_EMAIL'],
  manuallyManageConnections: false,
});

// Step 2: Generate user-specific server instance
const serverInstance = await composio.mcp.generate('user_123', mcpConfig.id);
const mcpUrl = serverInstance.url;

// @noErrors
// Can be used alongside regular tool management
const regularTools = await composio.tools.get({ toolkits: ['github'] });
const mcpSession = await composio.experimental.toolRouter.createSession(userId, {
  toolkits: ['gmail', 'slack']
});

// Both approaches can coexist and serve different purposes

# This would fail in versions 0.8.15-0.8.18
session = composio.experimental.tool_router.create_session(user_id='test')
# AttributeError: 'HttpClient' object has no attribute 'tool_router'

# This now works correctly
session = composio.experimental.tool_router.create_session(user_id='test')
# Returns: {'session_id': '...', 'url': '...'}