# Introduction import { Cards, Card } from "fumadocs-ui/components/card"; **For AI agents:** Start with the Markdown entry point at [`/llms.txt`](/llms.txt). Individual pages are also available as `.mdx` exports (for example, [`/docs/getting-started/basic-usage.mdx`](/docs/getting-started/basic-usage.mdx)). The Integrate SDK is a universal, type-safe TypeScript library that bridges your applications to third-party services through the Model Context Protocol (MCP). It provides seamless integration with services like GitHub, Gmail, Notion, and more, both in the browser and on the server, without the complexity of managing OAuth flows, API differences, or connection states. Why Integrate SDK? [#why-integrate-sdk] Building applications that connect to multiple third-party services is challenging. Each service has its own OAuth implementation, API quirks, and authentication patterns. You need to handle OAuth flows in the browser, manage tokens securely, make API calls from your backend, and deal with re-authentication when tokens expire. The Integrate SDK solves this by providing a unified, type-safe interface to all your integrations. You configure your OAuth credentials once, authorize users through a seamless flow (popup or redirect), and then make API calls from anywhere in your stack, whether that's client-side JavaScript, server-side API routes, or serverless functions. The SDK handles token management, streaming connections to the MCP server, and provides full TypeScript support so you know exactly what tools are available and what parameters they need. How It Works [#how-it-works] The SDK connects to the Integrate MCP server (`https://mcp.integrate.dev/api/v1/mcp`) using HTTP streaming with newline-delimited JSON. You bring your own OAuth app credentials for each integration you want to use, whether that's a GitHub OAuth app, Google Cloud project, or Notion integration. When a user authorizes your app, the OAuth flow happens through the server, which securely stores the credentials. The SDK receives a session token that it uses for all subsequent API calls. This token works everywhere: in the browser for rich user experiences, in your Next.js API routes for server-side operations, or in your Node.js backend services. **Important:** You control your own OAuth applications and credentials. The SDK acts as a secure bridge, sending your OAuth configuration to the Integrate server which handles the complex authentication flows and API calls on your behalf. Features [#features] The Integrate SDK is designed to be both powerful and simple to use: * πŸ”Œ **Integration-Based Architecture** - Enable only the integrations you need, reducing bundle size and surface area * πŸ”’ **Type-Safe** - Full TypeScript support with IntelliSense for every tool, parameter, and response * 🌊 **Real-time Communication** - HTTP streaming with NDJSON for efficient, real-time data flow * πŸ” **Complete OAuth Flow** - Built-in OAuth 2.0 with PKCE support in both popup and redirect modes * ⏰ **Scheduled Triggers** - Schedule tool executions for specific times or recurring intervals with cron expressions * 🌍 **Universal** - Works seamlessly in browsers, Node.js, Edge runtimes, and serverless environments * πŸ› οΈ **Extensible** - Add any integration supported by the Integrate MCP server with simple integration configuration * πŸ“¦ **Zero Dependencies** - Lightweight implementation with no external dependencies * πŸ”„ **Automatic Re-authentication** - Handle token expiration gracefully with built-in re-auth flows * 🎯 **Tool Discovery** - Automatically discover available tools based on your enabled integrations Get Started [#get-started] The Journey of an Integration [#the-journey-of-an-integration] Here's what happens when you integrate a third-party service into your application: 1. Configuration [#1-configuration] You configure the SDK with integrations for each service you want to use: GitHub for repository management, Gmail for email, Notion for knowledge base access, and so on. Each integration knows what OAuth credentials it needs and what tools it provides. 2. Authorization [#2-authorization] When a user needs to connect their account, the SDK orchestrates the OAuth 2.0 flow. In the browser, this happens seamlessly through a popup or redirect. The user authorizes your app with the third-party service, and the Integrate server securely stores their credentials. 3. Connection [#3-connection] The SDK establishes a streaming connection to `https://mcp.integrate.dev/api/v1/mcp` and receives a session token. This token is your golden ticket: it represents the user's authorized connections and works anywhere in your application. 4. Discovery [#4-discovery] The SDK queries the server for available tools and intelligently filters them based on your enabled integrations. With full TypeScript support, your IDE immediately knows what tools are available, what parameters they accept, and what they return. 5. Execution [#5-execution] When you call a tool (for example, creating a GitHub issue or sending an email), the SDK sends a JSON-RPC request over the streaming connection. The server executes the action using the stored OAuth credentials and streams the response back to your application. 6. Persistence [#6-persistence] Session tokens can be persisted across page reloads and shared between client and server. Once a user has authorized your app in the browser, your backend services can use the same token to make API calls on their behalf. Universal by Design [#universal-by-design] The SDK adapts to its environment, providing the right capabilities for each context: 🌐 Browser Environments [#-browser-environments] In the browser, the SDK provides the complete user experience. Users can authorize their accounts through intuitive popup or redirect flows. The SDK manages session tokens, makes API calls, and handles re-authentication when needed. It's perfect for building rich, interactive experiences where users directly interact with their connected services. πŸ–₯️ Server Environments [#️-server-environments] On the server, whether that's Node.js, Edge runtimes, or serverless functions, the SDK focuses on execution. Given a valid session token (typically obtained from browser authorization and passed via cookies or headers), it makes API calls efficiently without any UI concerns. This is ideal for backend operations, scheduled jobs, or API routes that need to interact with third-party services on behalf of users. πŸ”„ The Typical Pattern [#-the-typical-pattern] Most applications follow this pattern: handle OAuth authorization in the browser where users can interact with the authorization UI, then share the session token with your backend through secure HTTP-only cookies or authorization headers. Your server-side code can then make API calls using the same session token, maintaining a seamless experience across your entire stack. Technical Details [#technical-details] The SDK communicates with the Integrate MCP server using the Model Context Protocol: * **Endpoint:** `https://mcp.integrate.dev/api/v1/mcp` * **Protocol:** MCP over HTTP streaming for real-time, efficient communication * **Format:** Newline-delimited JSON (NDJSON) for progressive responses * **Methods:** `initialize`, `tools/list`, `tools/call` for complete integration lifecycle * **Security:** OAuth 2.0 with PKCE for secure authorization flows # Drizzle The Drizzle adapter stores provider tokens and triggers using your existing Drizzle schema. Install [#install] ```bash bun add integrate-sdk drizzle-orm ``` `drizzle-orm` is a peer dependency of the adapter. Schema [#schema] Define `provider_token` and optional `trigger` tables. You can copy the [reference schema](/docs/database/schema) or align your existing tables with the same column names. ```typescript // db/schema/integrate.ts import { integrateProviderToken, integrateTrigger } from "integrate-sdk/server"; export const providerToken = integrateProviderToken; export const trigger = integrateTrigger; ``` Configuration [#configuration] ```typescript import { createMCPServer, githubIntegration } from "integrate-sdk/server"; import { drizzleAdapter } from "integrate-sdk/adapters/drizzle"; import { db } from "./db"; import { providerToken, trigger } from "./db/schema"; export const { client } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [githubIntegration({ scopes: ["repo"] })], database: drizzleAdapter(db, { provider: "pg", // "pg" | "mysql" | "sqlite" schema: { providerToken, trigger }, hooks: { onTokenChange: ({ userId }) => revalidateTag(`integrations:${userId}`), }, }), getSessionContext: async (req) => { const session = await auth.api.getSession({ headers: req.headers }); return session?.user?.id ? { userId: session.user.id } : undefined; }, }); ``` Session context example [#session-context-example] Integrate's Drizzle adapter persists **integration OAuth tokens** in `provider_token`. It is separate from your app's user/session tablesβ€”wire `getSessionContext` to whatever auth layer you already use. ```typescript import { auth } from "./auth"; import { drizzleAdapter } from "integrate-sdk/adapters/drizzle"; database: drizzleAdapter(db, { provider: "pg", schema: { providerToken, trigger }, }), getSessionContext: async (req) => { const session = await auth.api.getSession({ headers: req.headers }); if (!session?.user?.id) return undefined; return { userId: session.user.id, organizationId: session.session?.activeOrganizationId, }; }, ``` API [#api] ```typescript drizzleAdapter(db, { provider: "pg", schema: { providerToken, trigger? }, hooks?: IntegrateAdapterHooks, debugLogs?: boolean, }) ``` Returns a lazy factory `() => IntegrateDatabaseCallbacks` compatible with `createMCPServer({ database })`. You can also use `drizzleAdapterCallbacks(db, config)` if you need the callback object directly without the factory wrapper. Multi-account tokens [#multi-account-tokens] The adapter handles multiple accounts per provider via `account_email` and `account_id`. See [Schema](/docs/database/schema) for the recommended unique index. Example [#example] See the [Drizzle database example](https://github.com/integratedotdev/examples/tree/main/database/drizzle-example) for a complete Next.js app with SQLite and GitHub OAuth. # Hooks Database adapters accept optional `hooks` to customize token persistence and trigger authorization without forking the SDK. ```typescript drizzleAdapter(db, { provider: "pg", schema: { providerToken, trigger }, hooks: { onTokenChange: async ({ userId, provider, action }) => { /* ... */ }, resolveAccountIdentity: async (provider, tokenData, emailHint, context) => { /* ... */ }, authorizeTrigger: async (row, context) => { /* ... */ }, }, }); ``` onTokenChange [#ontokenchange] Called after a token is saved or removed. ```typescript onTokenChange: ({ userId, provider, action }) => { // action: "set" | "remove" revalidateTag(`library-integrations:${userId}`); }, ``` Use for cache invalidation, analytics, or webhooks. resolveAccountIdentity [#resolveaccountidentity] Resolve `account_email` and `account_id` before upserting a token. The default derives `accountId` from `provider:email` when email is known. For GitHub, fetch the user's profile when email is missing: ```typescript resolveAccountIdentity: async (provider, tokenData, emailHint) => { let accountEmail = normalizeAccountEmail(emailHint); let accountId = tokenData.accountId ?? null; if (provider === "github" && (!accountEmail || !accountId)) { const identity = await resolveGitHubIdentity(tokenData.accessToken); accountEmail = accountEmail ?? identity.accountEmail; accountId = accountId ?? identity.accountId; } if (!accountId && accountEmail) { accountId = `${provider}:${accountEmail}`; } return { accountEmail, accountId }; }, ``` Import helpers from `integrate-sdk/server`: ```typescript import { normalizeAccountEmail } from "integrate-sdk/server"; ``` authorizeTrigger [#authorizetrigger] Called when loading or mutating a trigger. Return a (possibly updated) row, or `null` to deny access. Use for ownership repair when `user_id` on the trigger row is stale: ```typescript authorizeTrigger: async (row) => { const ownerId = await resolveOwnerFromAutomationTables(row.id); if (ownerId && ownerId !== row.userId) { await db.update(trigger).set({ userId: ownerId }).where(eq(trigger.id, row.id)); return { ...row, userId: ownerId }; } return row; }, ``` After the hook, the adapter checks `context.userId` against the returned row's `userId`. getSessionContext (not a hook) [#getsessioncontext-not-a-hook] Session resolution stays on `createMCPServer`, not the adapter. Wire your auth library or internal headers: ```typescript getSessionContext: async (req) => { const internal = resolveCronActor(req); if (internal) return internal; const session = await auth.api.getSession({ headers: req.headers }); return session?.user?.id ? { userId: session.user.id } : undefined; }, ``` Raw callbacks override hooks [#raw-callbacks-override-hooks] If you pass explicit `getProviderToken` / `setProviderToken` / `removeProviderToken` or individual `triggers.*` callbacks on `createMCPServer`, those take precedence over the adapter. Hooks still run inside the adapter for operations the adapter handles. # Database The Integrate SDK can persist OAuth provider tokens and scheduled triggers in your database instead of relying on hand-written callbacks for every CRUD operation. This enables: * **Multi-device sync**: Access tokens across devices and sessions * **Server-side usage**: Use tokens in API routes and background jobs * **Long-term persistence**: Tokens survive browser clears and device changes * **Trigger storage**: Schedule tool executions with database-backed triggers Adapters vs callbacks [#adapters-vs-callbacks] You can configure persistence in two ways: | Approach | When to use | | ---------------------------------- | ------------------------------------------------------------------------------ | | **Database adapter** (recommended) | Drizzle, Prisma, or MongoDB. Same callback shape as hand-written token storage | | **Raw callbacks** | Custom storage, legacy setups, or non-standard schemas | With adapters, pass `database` to `createMCPServer`. Token and trigger CRUD are handled for you. You still provide **`getSessionContext`** to map requests to a `userId` (session cookie, Clerk, service headers, etc.). ```typescript import { createMCPServer, githubIntegration } from "integrate-sdk/server"; import { drizzleAdapter } from "integrate-sdk/adapters/drizzle"; import { db } from "./db"; import { providerToken, trigger } from "./db/schema"; export const { client } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [githubIntegration({ scopes: ["repo"] })], database: drizzleAdapter(db, { provider: "pg", schema: { providerToken, trigger }, }), getSessionContext: async (req) => { const session = await auth.api.getSession({ headers: req.headers }); return session?.user?.id ? { userId: session.user.id } : undefined; }, }); ``` Explicit callbacks on `createMCPServer` still work and **override** adapter defaults when both are set. Connected-provider tool loading [#connected-provider-tool-loading] When using a database adapter, pair token storage with [connected-only tool discovery](/docs/guides/mcp-tool-scoping): ```typescript import { getVercelAITools } from "integrate-sdk/server"; const tools = await getVercelAITools(serverClient, { context: { userId: session.user.id }, connectedOnly: true, mode: "code", }); ``` Use `listConnectedProviders` from `integrate-sdk/server` when you need the connected provider list outside AI helpers. Guides [#guides] * [Drizzle](/docs/database/drizzle): PostgreSQL, MySQL, SQLite * [Prisma](/docs/database/prisma): `@prisma/client` * [MongoDB](/docs/database/mongodb): native driver collections * [Schema](/docs/database/schema): canonical tables and indexes * [Triggers](/docs/database/triggers): composing `onComplete` and `getCallbackUrl` * [Hooks](/docs/database/hooks): cache invalidation, identity resolution, trigger authorization Examples [#examples] Runnable Next.js examples for each database adapter live in the [examples repository](https://github.com/integratedotdev/examples): | Adapter | Example | | ------- | ------------------------------------------------------------------------------------------------------------ | | Drizzle | [`database/drizzle-example`](https://github.com/integratedotdev/examples/tree/main/database/drizzle-example) | | Prisma | [`database/prisma-example`](https://github.com/integratedotdev/examples/tree/main/database/prisma-example) | | MongoDB | [`database/mongodb-example`](https://github.com/integratedotdev/examples/tree/main/database/mongodb-example) | Each example connects GitHub OAuth, persists tokens with the adapter, and lists repositories from the browser. What stays app-specific [#what-stays-app-specific] `getSessionContext` cannot be fully abstracted. Each app wires its auth library or internal service headers. Optional [hooks](/docs/database/hooks) cover app-specific behavior (cache revalidation, GitHub email resolution, trigger ownership repair) without forking the adapter. Next steps [#next-steps] * [OAuth authorization](/docs/getting-started/basic-usage) * [Triggers (getting started)](/docs/getting-started/triggers) * [Built-in Integrations](/docs/integrations) # MongoDB The MongoDB adapter stores documents in configurable collections with string `id` fields (no `ObjectId` requirement). Install [#install] ```bash bun add integrate-sdk mongodb ``` Collections [#collections] Default collection names: | Collection | Purpose | | ----------------- | ------------------ | | `provider_tokens` | OAuth tokens | | `triggers` | Scheduled triggers | Documents use a string `id` field as the primary key, plus camelCase fields matching the [canonical schema](/docs/database/schema). Configuration [#configuration] ```typescript import { createMCPServer } from "integrate-sdk/server"; import { mongodbAdapter } from "integrate-sdk/adapters/mongodb"; import { MongoClient } from "mongodb"; const client = new MongoClient(process.env.MONGODB_URI!); const db = client.db("myapp"); export const { client: integrateClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [...], database: mongodbAdapter(db, { collectionNames: { providerTokens: "provider_tokens", triggers: "triggers", }, }), getSessionContext: async (req) => { /* ... */ }, }); ``` API [#api] ```typescript mongodbAdapter(db, { client?: MongoClient, collectionNames?: { providerTokens?: string; triggers?: string; }, hooks?: IntegrateAdapterHooks, debugLogs?: boolean, }) ``` Pass `client` if you need lifecycle management outside the adapter. Triggers are enabled when `collectionNames.triggers` is set (default: `"triggers"`). Indexes [#indexes] Create indexes for production workloads: ```javascript db.provider_tokens.createIndex({ userId: 1, provider: 1 }); db.provider_tokens.createIndex( { userId: 1, provider: 1, accountEmail: 1 }, { unique: true, sparse: true } ); db.triggers.createIndex({ userId: 1, status: 1 }); db.triggers.createIndex({ nextRunAt: 1 }); ``` Example [#example] See the [MongoDB database example](https://github.com/integratedotdev/examples/tree/main/database/mongodb-example) for a complete Next.js app with GitHub OAuth. # Prisma The Prisma adapter uses dynamic model access (`prisma.providerToken.findFirst`, etc.) so you can map custom model names. Install [#install] ```bash bun add integrate-sdk @prisma/client ``` Prisma schema [#prisma-schema] ```prisma model ProviderToken { id String @id userId String @map("user_id") provider String accountEmail String? @map("account_email") accountId String? @map("account_id") accessToken String @map("access_token") refreshToken String? @map("refresh_token") tokenType String @default("Bearer") @map("token_type") expiresAt DateTime? @map("expires_at") scope String? createdAt DateTime @default(now()) @map("created_at") updatedAt DateTime @updatedAt @map("updated_at") @@unique([userId, provider, accountEmail]) @@map("provider_token") } model Trigger { id String @id userId String? @map("user_id") name String? description String? toolName String @map("tool_name") toolArguments Json @map("tool_arguments") scheduleType String @map("schedule_type") scheduleValue String @map("schedule_value") status String @default("active") provider String? lastRunAt DateTime? @map("last_run_at") nextRunAt DateTime? @map("next_run_at") runCount Int @default(0) @map("run_count") lastError String? @map("last_error") lastResult Json? @map("last_result") createdAt DateTime @default(now()) @map("created_at") updatedAt DateTime @updatedAt @map("updated_at") @@map("trigger") } ``` See [Schema](/docs/database/schema) for field semantics. Configuration [#configuration] ```typescript import { createMCPServer } from "integrate-sdk/server"; import { prismaAdapter } from "integrate-sdk/adapters/prisma"; import { prisma } from "./db"; export const { client } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [...], database: prismaAdapter(prisma, { provider: "postgresql", // dialect hint for date handling modelNames: { providerToken: "providerToken", trigger: "trigger", }, }), getSessionContext: async (req) => { /* ... */ }, }); ``` API [#api] ```typescript prismaAdapter(prisma, { provider?: "postgresql" | "mysql" | "sqlite", modelNames?: { providerToken?: string; trigger?: string; }, hooks?: IntegrateAdapterHooks, debugLogs?: boolean, }) ``` Triggers are enabled when a `trigger` model is configured in `modelNames`. Example [#example] See the [Prisma database example](https://github.com/integratedotdev/examples/tree/main/database/prisma-example) for a complete Next.js app with SQLite and GitHub OAuth. # Schema Database adapters expect tables (or collections) with these fields. Column names use snake\_case in SQL; Drizzle/Prisma models typically map to camelCase. provider_token [#provider_token] Stores OAuth access and refresh tokens per user, provider, and account. | Column | Type | Notes | | --------------- | ------------------- | ---------------------------------------------- | | `id` | text | Primary key | | `user_id` | text | Owner user | | `provider` | text | e.g. `github`, `gmail` | | `account_email` | text, nullable | Identifies account for multi-account providers | | `account_id` | text, nullable | Provider-specific account id | | `access_token` | text | Required | | `refresh_token` | text, nullable | | | `token_type` | text | Default `Bearer` | | `expires_at` | timestamp, nullable | | | `scope` | text, nullable | Space-separated scopes | | `created_at` | timestamp | | | `updated_at` | timestamp | | Indexes [#indexes] ```sql CREATE INDEX provider_token_user_id_idx ON provider_token(user_id); CREATE INDEX provider_token_provider_idx ON provider_token(provider); CREATE INDEX provider_token_user_provider_idx ON provider_token(user_id, provider); CREATE UNIQUE INDEX provider_token_user_provider_account_email_uidx ON provider_token(user_id, provider, account_email); ``` The unique index on `(user_id, provider, account_email)` supports multiple accounts per provider. Legacy rows with null `account_email` may coexist until migrated. Reference Drizzle schema [#reference-drizzle-schema] Import from the SDK: ```typescript import { integrateProviderToken } from "integrate-sdk/server"; ``` Or copy from `integrate-sdk` source: `src/database/schemas/drizzle.ts`. trigger [#trigger] Stores scheduled tool executions. | Column | Type | Notes | | ---------------- | -------------------- | ----------------------------------------- | | `id` | text | Primary key | | `user_id` | text, nullable | Owner; may be repaired via hooks | | `name` | text, nullable | | | `description` | text, nullable | | | `tool_name` | text | MCP tool to execute | | `tool_arguments` | json/jsonb | Tool arguments | | `schedule_type` | text | `once` or `cron` | | `schedule_value` | text | ISO timestamp (once) or cron expression | | `status` | text | `active`, `paused`, `completed`, `failed` | | `provider` | text, nullable | OAuth provider for the tool | | `last_run_at` | timestamp, nullable | | | `next_run_at` | timestamp, nullable | | | `run_count` | integer | Default 0 | | `last_error` | text, nullable | | | `last_result` | json/jsonb, nullable | | | `created_at` | timestamp | | | `updated_at` | timestamp | | Indexes [#indexes-1] ```sql CREATE INDEX trigger_user_id_idx ON trigger(user_id); CREATE INDEX trigger_status_idx ON trigger(status); CREATE INDEX trigger_next_run_at_idx ON trigger(next_run_at); ``` ProviderTokenData mapping [#providertokendata-mapping] When the SDK reads tokens, it returns: ```typescript interface ProviderTokenData { accessToken: string; refreshToken?: string; tokenType: string; expiresIn: number; expiresAt?: string; scopes?: string[]; email?: string; accountId?: string; } ``` The adapter selects the best row when multiple accounts exist (email/accountId hints from context or OAuth flow). Raw callbacks [#raw-callbacks] If you do not use an adapter, implement `getProviderToken`, `setProviderToken`, and `removeProviderToken` manually. See the legacy guide content in the [Database overview](/docs/database) and [Triggers](/docs/database/triggers) pages. # Triggers When your schema includes a `trigger` table (or MongoDB collection), database adapters register `TriggerCallbacks` for create, get, list, update, and delete. The MCP scheduler calls your app to load triggers and OAuth tokens at execution time. Adapter + app callbacks [#adapter--app-callbacks] Merge adapter defaults with app-specific completion logic: ```typescript import { createMCPServer } from "integrate-sdk/server"; import { drizzleAdapter } from "integrate-sdk/adapters/drizzle"; export const { client } = createMCPServer({ database: drizzleAdapter(db, { provider: "pg", schema: { providerToken, trigger }, }), getSessionContext: async (req) => { /* ... */ }, triggers: { // Adapter provides create, get, list, update, delete onComplete: async (context) => { return handleTriggerCompletion(context); }, getCallbackUrl: () => process.env.APP_URL!, }, }); ``` Explicit `triggers` fields override adapter callbacks. Only specify what you need beyond CRUD. onComplete [#oncomplete] `onComplete` runs after a trigger step finishes. Use it for multi-step workflows, notifications, or updating related app tables. It is **not** part of the database adapter; keep it in your `createMCPServer` config. getCallbackUrl [#getcallbackurl] Return the public origin the MCP scheduler should call back into your app (e.g. `https://app.example.com`). Authorization [#authorization] By default, trigger get/update/delete enforce `context.userId` matches `trigger.user_id`. For ownership repair (e.g. triggers linked via automation tables), use the [`authorizeTrigger` hook](/docs/database/hooks). Schedule format [#schedule-format] The SDK accepts nested schedules on create: ```typescript { type: "once", runAt: "2026-06-13T12:00:00.000Z" } { type: "cron", expression: "0 9 * * *" } ``` Adapters flatten these to `schedule_type` and `schedule_value` in the database. See [Schema](/docs/database/schema). Without an adapter [#without-an-adapter] You can still implement `triggers: { create, get, list, update, delete, onComplete, getCallbackUrl }` manually. See [Getting Started: Triggers](/docs/getting-started/triggers) for the full callback API. # Anthropic Claude The Integrate SDK provides seamless integration with Anthropic's Claude API, allowing Claude to access your integrations through MCP tools. Installation [#installation] Install the Integrate SDK and Anthropic SDK packages: ```bash bun add integrate-sdk @anthropic-ai/sdk ``` Setup [#setup] Setting up Anthropic integration requires **3 files** (or **5 files** if not using a database): 1. Server Configuration [#1-server-configuration] Create a server configuration file with your OAuth credentials: ```typescript // lib/integrate.ts import { createMCPServer, githubIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); ``` 2. Providers (only if no database) [#2-providers-only-if-no-database] If you're not using a database, create a providers component that injects tokens: ```typescript // app/providers.tsx "use client"; import { client } from "integrate-sdk"; import { useIntegrateAI } from "integrate-sdk/react"; export function Providers({ children }: { children: React.ReactNode }) { useIntegrateAI(client); return <>{children}; } ``` 3. Layout (only if no database) [#3-layout-only-if-no-database] Wrap your app with the Providers component: ```typescript // app/layout.tsx import { Providers } from "./providers"; export default function RootLayout({ children, }: Readonly<{ children: React.ReactNode; }>) { return ( {children} ); } ``` 4. OAuth Handler [#4-oauth-handler] Create a catch-all route that handles OAuth operations at `app/api/integrate/[...all]/route.ts`: ```typescript import { serverClient } from "@/lib/integrate"; import { toNextJsHandler } from "integrate-sdk/server"; export const { POST, GET } = toNextJsHandler(serverClient); ``` 5. Chat API Route [#5-chat-api-route] Create a chat route that converts MCP tools to Anthropic format: ```typescript // app/api/chat/route.ts import { serverClient } from "@/lib/integrate"; import { getAnthropicTools } from "integrate-sdk/server"; import Anthropic from "@anthropic-ai/sdk"; import { handleAnthropicMessage } from "integrate-sdk/ai/anthropic"; const anthropic = new Anthropic(); export async function POST(req: Request) { const { messages } = await req.json(); const msg = await anthropic.messages.create({ model: "claude-sonnet-4-5", messages, tools: await getAnthropicTools(serverClient), max_tokens: 1000, }); const result = await handleAnthropicMessage(serverClient, msg); return Response.json(result); } ``` Usage [#usage] Use Anthropic's Claude in any component: ```typescript // app/page.tsx "use client"; import { useState, useEffect } from "react"; import { client } from "integrate-sdk"; import Anthropic from "@anthropic-ai/sdk"; import { Streamdown } from "streamdown"; export default function ChatPage() { const [messages, setMessages] = useState([]); const [input, setInput] = useState(""); const [loading, setLoading] = useState(false); const [githubAuthorized, setGithubAuthorized] = useState(false); useEffect(() => { client.isAuthorized("github").then(setGithubAuthorized); }, []); async function handleGithubClick() { try { if (githubAuthorized) { await client.disconnectProvider("github"); } else { await client.authorize("github"); } setGithubAuthorized(client.isAuthorized("github")); } catch (error) { console.error("Error:", error); } } async function handleSubmit(e: React.FormEvent) { e.preventDefault(); if (!input.trim()) return; const userMessage: Anthropic.MessageParam = { role: "user", content: input, }; setMessages((prev) => [...prev, userMessage]); setInput(""); setLoading(true); try { const response = await fetch("/api/chat", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ messages: [...messages, userMessage], }), }); const data = await response.json(); const newMessages = Array.isArray(data) ? data : [data]; setMessages((prev) => [ ...prev, ...newMessages.map((msg: Anthropic.MessageParam) => ({ role: msg.role, content: msg.content, })), ]); } catch (error) { console.error("Error:", error); } finally { setLoading(false); } } const renderContent = ( content: Anthropic.MessageParam["content"], isAssistant: boolean ) => { if (typeof content === "string") { if (isAssistant) { return {content}; } return
{content}
; } if (Array.isArray(content)) { return (
{content.map((block, index) => { if (block.type === "text") { if (isAssistant) { return ( {block.text} ); } return (
{block.text}
); } if (block.type === "tool_use") { return null; } if (block.type === "tool_result") { let displayContent = block.content; if (typeof block.content === "string") { try { const parsed = JSON.parse(block.content); if (parsed.content && Array.isArray(parsed.content)) { return (
{parsed.content.map( ( innerBlock: { type: string; text: string }, innerIndex: number ) => { if (innerBlock.type === "text") { return (
{innerBlock.text}
); } return null; } )}
); } displayContent = JSON.stringify(parsed, null, 2); } catch {} } return (
{typeof displayContent === "string" ? displayContent : JSON.stringify(displayContent)}
); } return null; })}
); } return JSON.stringify(content); }; return (
{messages.map((m, i) => { let hasRenderableContent = false; let isToolResult = false; if (typeof m.content === "string") hasRenderableContent = true; else if (Array.isArray(m.content)) { hasRenderableContent = m.content.some( (block) => block.type === "text" || block.type === "tool_result" ); isToolResult = m.content.some( (block) => block.type === "tool_result" ); } if (!hasRenderableContent) return null; const alignmentClass = m.role === "user" && !isToolResult ? "text-right" : "text-left"; return (
{renderContent( m.content, m.role === "assistant" || isToolResult )}
); })}
setInput(e.target.value)} placeholder="Ask Claude anything..." className="w-full px-4 py-2 border border-gray-500 rounded-lg" disabled={loading} />
); } ``` Next Steps [#next-steps] * Explore [Advanced Configuration](/docs/getting-started/advanced-usage) * Check the [API Reference](/docs/reference/options) for complete type definitions # Code Mode Code Mode is the default way the Integrate SDK exposes your integrations to AI models. Instead of sending every MCP tool (potentially hundreds across 25+ integrations) to the model on each request, Code Mode hands the LLM a single `execute_code` tool and a typed TypeScript API it can write code against. The LLM writes a snippet, the snippet runs in an isolated [Vercel Sandbox](https://vercel.com/docs/vercel-sandbox), and the results come back in one round-trip, no matter how many integrations the code touches. Why Code Mode [#why-code-mode] | | Per-tool (legacy) | Code Mode | | -------------------------------- | ----------------------------------- | -------------------------------- | | Tools sent to model | 1 per MCP tool (25+ Γ— N) | 1 (`execute_code`) | | Round-trips for multi-step tasks | 1 per tool call | 1 for the whole snippet | | Context window pressure | High (full tool list every request) | Low (typed API surface only) | | Model strength | Structured tool-calling | Writing code (what LLMs do best) | Requirements [#requirements] Install the sandbox peer dependency: ```bash bun add @vercel/sandbox ``` Code Mode needs a publicly reachable URL for your app so the sandbox can call back into your `/api/integrate/mcp` route. Set this in your server config: ```typescript // lib/integrate.ts import { createMCPServer, githubIntegration, gmailIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"] }), gmailIntegration({ scopes: ["gmail.send", "gmail.readonly"] }), ], codeMode: { publicUrl: process.env.INTEGRATE_URL, // e.g. "https://myapp.com" }, }); ``` Or set the environment variable directly (no config change needed): ```bash INTEGRATE_URL=https://myapp.com ``` Code Mode will return a clear error if `publicUrl` is not set. The sandbox needs it to call back into your `/api/integrate/mcp` route. On the server, set `codeMode.publicUrl` in `createMCPServer` or export `INTEGRATE_URL`. Auto-detection uses either value. Scoping tools to connected integrations [#scoping-tools-to-connected-integrations] Code Mode reduces tools sent to the model, but discovery can still fetch every configured integration on cold start. Pass `connectedOnly` with a user context so only OAuth-connected integrations are loaded: ```typescript const tools = await getVercelAITools(serverClient, { context: { userId: session.user.id }, connectedOnly: true, mode: "code", }); ``` See [MCP Tool Scoping](/docs/guides/mcp-tool-scoping) and [Performance](/docs/guides/performance). Usage [#usage] No API changes are required. `getVercelAITools`, `getOpenAITools`, `getAnthropicTools`, and `getGoogleTools` all default to Code Mode automatically. Vercel AI SDK [#vercel-ai-sdk] ```typescript // app/api/chat/route.ts import { serverClient } from "@/lib/integrate"; import { getVercelAITools } from "integrate-sdk/server"; import { convertToModelMessages, stepCountIs, streamText } from "ai"; export async function POST(req: Request) { const { messages } = await req.json(); const result = streamText({ model: "openai/gpt-4o", messages: convertToModelMessages(messages), tools: await getVercelAITools(serverClient), // Code Mode is the default stopWhen: stepCountIs(3), }); return result.toUIMessageStreamResponse(); } ``` OpenAI [#openai] ```typescript // app/api/chat/route.ts import { serverClient } from "@/lib/integrate"; import { getOpenAITools, handleOpenAIResponse } from "integrate-sdk/server"; import OpenAI from "openai"; const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY }); export async function POST(req: Request) { const { messages } = await req.json(); const response = await openai.responses.create({ model: "gpt-4o", input: messages, tools: await getOpenAITools(serverClient), // Code Mode is the default }); const result = await handleOpenAIResponse(serverClient, response); return Response.json(result); } ``` Anthropic [#anthropic] ```typescript // app/api/chat/route.ts import { serverClient } from "@/lib/integrate"; import { getAnthropicTools, handleAnthropicMessage } from "integrate-sdk/server"; import Anthropic from "@anthropic-ai/sdk"; const anthropic = new Anthropic(); export async function POST(req: Request) { const { messages } = await req.json(); const msg = await anthropic.messages.create({ model: "claude-sonnet-4-5", messages, tools: await getAnthropicTools(serverClient), // Code Mode is the default max_tokens: 4096, }); const result = await handleAnthropicMessage(serverClient, msg); return Response.json(result); } ``` Google GenAI [#google-genai] ```typescript // app/api/chat/route.ts import { serverClient } from "@/lib/integrate"; import { getGoogleTools, executeGoogleFunctionCalls } from "integrate-sdk/server"; import { GoogleGenAI } from "@google/genai"; const ai = new GoogleGenAI({ apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY }); export async function POST(req: Request) { const { messages } = await req.json(); const response = await ai.models.generateContent({ model: "gemini-2.0-flash-001", contents: messages, config: { tools: [{ functionDeclarations: await getGoogleTools(serverClient) }], // Code Mode is the default }, }); if (response.functionCalls?.length) { const results = await executeGoogleFunctionCalls(serverClient, response.functionCalls); return Response.json(results); } return Response.json(response); } ``` What the LLM sees [#what-the-llm-sees] When Code Mode is active, the model receives a single `execute_code` tool whose description contains a generated TypeScript API derived from your enabled integrations: ```typescript export interface GithubClient { /** Create a new issue in a repository */ createIssue(args: { /** Repository owner */ owner: string; repo: string; title: string; body?: string; labels?: string[]; }): Promise; /** List repositories for the authenticated user */ listRepos(args?: { visibility?: "all" | "public" | "private" }): Promise; } export interface GmailClient { /** Send an email */ sendMessage(args: { to: string; subject: string; body: string; }): Promise; } export interface Client { github: GithubClient; gmail: GmailClient; } export declare const client: Client; ``` The model writes code against this surface. A multi-step task that would have required multiple round-trips with per-tool mode is handled in one: ```typescript // What the LLM writes inside execute_code: const issues = await client.github.listIssues({ owner: "acme", repo: "api" }); const open = JSON.parse(issues.content[0].text).filter((i: any) => i.state === "open"); for (const issue of open.slice(0, 3)) { await client.gmail.sendMessage({ to: "team@acme.com", subject: `Open issue: ${issue.title}`, body: `#${issue.number} - ${issue.html_url}`, }); } return { notified: open.slice(0, 3).map((i: any) => i.number) }; ``` Advanced configuration [#advanced-configuration] ```typescript createMCPServer({ // ... codeMode: { publicUrl: process.env.INTEGRATE_URL, runtime: "node24", // "node22" (default) or "node24" timeoutMs: 30_000, // sandbox timeout, default 60_000 vcpus: 1, // default 2 }, }); ``` Opting out [#opting-out] If you need the legacy behavior (one tool per MCP tool), pass `mode: 'tools'` to any helper: ```typescript // One tool per integration method. Useful if your model doesn't handle code well. const tools = await getVercelAITools(serverClient, { mode: "tools" }); const tools = await getOpenAITools(serverClient, { mode: "tools" }); const tools = await getAnthropicTools(serverClient, { mode: "tools" }); const tools = await getGoogleTools(serverClient, { mode: "tools" }); ``` Authentication [#authentication] OAuth works exactly as before. The user authenticates once via the standard OAuth popup, and their tokens are automatically forwarded through the sandbox to every tool call the LLM code makes. No changes to your auth setup are required. # Google GenAI The Integrate SDK provides seamless integration with Google's Generative AI SDK (Gemini), allowing AI models to access your integrations through MCP tools. Installation [#installation] Install the Integrate SDK and Google GenAI packages: ```bash bun add integrate-sdk @google/generative-ai ``` Setup [#setup] Setting up Google GenAI integration requires **3 files** (or **5 files** if not using a database): 1. Server Configuration [#1-server-configuration] Create a server configuration file with your OAuth credentials: ```typescript // lib/integrate.ts import { createMCPServer, githubIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); ``` 2. Providers (only if no database) [#2-providers-only-if-no-database] If you're not using a database, create a providers component that injects tokens: ```typescript // app/providers.tsx "use client"; import { client } from "integrate-sdk"; import { useIntegrateAI } from "integrate-sdk/react"; export function Providers({ children }: { children: React.ReactNode }) { useIntegrateAI(client); return <>{children}; } ``` 3. Layout (only if no database) [#3-layout-only-if-no-database] Wrap your app with the Providers component: ```typescript // app/layout.tsx import { Providers } from "./providers"; export default function RootLayout({ children, }: Readonly<{ children: React.ReactNode; }>) { return ( {children} ); } ``` 4. OAuth Handler [#4-oauth-handler] Create a catch-all route that handles OAuth operations at `app/api/integrate/[...all]/route.ts`: ```typescript import { serverClient } from "@/lib/integrate"; import { toNextJsHandler } from "integrate-sdk/server"; export const { POST, GET } = toNextJsHandler(serverClient); ``` 5. Chat API Route [#5-chat-api-route] Create a chat route that converts MCP tools to Google GenAI format: ```typescript // app/api/chat/route.ts import { serverClient } from "@/lib/integrate"; import { GoogleGenAI } from "@google/genai"; import { executeGoogleFunctionCalls, getGoogleTools, } from "integrate-sdk/server"; const ai = new GoogleGenAI({ apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY, }); export async function POST(req: Request) { const { messages } = await req.json(); const response = await ai.models.generateContent({ model: "gemini-2.0-flash-001", contents: messages, config: { tools: [{ functionDeclarations: await getGoogleTools(serverClient) }], }, }); if (response.functionCalls && response.functionCalls.length > 0) { const results = await executeGoogleFunctionCalls( serverClient, response.functionCalls ); return Response.json(results); } return Response.json(response); } ``` Usage [#usage] Use Google GenAI in any component: ```typescript // app/page.tsx "use client"; import { useState, useEffect } from "react"; import { client } from "integrate-sdk"; import { Streamdown } from "streamdown"; interface Message { role: "user" | "assistant"; content: string; } export default function ChatPage() { const [messages, setMessages] = useState([]); const [input, setInput] = useState(""); const [loading, setLoading] = useState(false); const [githubAuthorized, setGithubAuthorized] = useState(false); const isLoading = loading; useEffect(() => { client.isAuthorized("github").then(setGithubAuthorized); }, []); async function handleGithubClick() { try { if (githubAuthorized) { await client.disconnectProvider("github"); } else { await client.authorize("github"); } setGithubAuthorized(client.isAuthorized("github")); } catch (error) { console.error("Error:", error); } } function formatFunctionOutput(output: unknown): string { try { const data = typeof output === "string" ? JSON.parse(output) : output; if (data.structuredContent?.repositories) { let displayText = "\n\nπŸ“¦ **GitHub Repositories:**\n\n"; for (const repo of data.structuredContent.repositories) { displayText += `**${repo.name}**\n`; displayText += `${repo.html_url}\n`; if (repo.description) { displayText += `_${repo.description}_\n`; } displayText += `Language: ${repo.language || "N/A"} β€’ Stars: ${ repo.stargazers_count } β€’ ${repo.private ? "Private" : "Public"}\n\n`; } return displayText; } if (data.content && Array.isArray(data.content)) { let text = ""; for (const item of data.content) { if (item.type === "text" && item.text) { try { const parsed = JSON.parse(item.text); if (parsed.repositories) { let repoText = "\n\nπŸ“¦ **GitHub Repositories:**\n\n"; for (const repo of parsed.repositories) { repoText += `**${repo.name}**\n`; repoText += `${repo.html_url}\n`; if (repo.description) { repoText += `_${repo.description}_\n`; } repoText += `Language: ${repo.language || "N/A"} β€’ Stars: ${ repo.stargazers_count } β€’ ${repo.private ? "Private" : "Public"}\n\n`; } text += repoText; } else { text += JSON.stringify(parsed, null, 2); } } catch { text += item.text; } } } return text; } return JSON.stringify(data, null, 2); } catch (e) { console.error("Error formatting function output:", e); return String(output); } } async function handleSubmit(e: React.FormEvent) { e.preventDefault(); if (!input.trim()) return; const userMessage: Message = { role: "user", content: input }; setMessages((prev) => [...prev, userMessage]); setInput(""); setLoading(true); try { const googleMessages = [...messages, userMessage].map((msg) => ({ role: msg.role === "assistant" ? "model" : "user", parts: [{ text: msg.content }], })); const response = await fetch("/api/chat", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ messages: googleMessages, }), }); if (!response.ok) { throw new Error(`HTTP error! status: ${response.status}`); } const result = await response.json(); let assistantContent = ""; if (result.structuredContent) { assistantContent = formatFunctionOutput(result); } else if (result.text) { assistantContent = result.text; } else if (result.candidates && result.candidates[0]?.content) { const content = result.candidates[0].content; if (content.parts) { for (const part of content.parts) { if (part.text) { assistantContent += part.text; } } } } else if (Array.isArray(result)) { for (const item of result) { if (typeof item === "string") { try { const parsed = JSON.parse(item); if (parsed.structuredContent) { assistantContent += formatFunctionOutput(parsed); } else { assistantContent += item; } } catch { assistantContent += item; } } else if (item.structuredContent) { assistantContent += formatFunctionOutput(item); } else if (item.type === "function_call_output") { assistantContent += formatFunctionOutput(item.output); } else if (item.content && Array.isArray(item.content)) { for (const contentItem of item.content) { if (contentItem.text) { assistantContent += formatFunctionOutput(contentItem.text); } } } } } if (!assistantContent.trim()) { assistantContent = "Response received but no displayable content found."; } setMessages((prev) => [ ...prev, { role: "assistant", content: assistantContent.trim() }, ]); } catch (error) { console.error("Error:", error); setMessages((prev) => [ ...prev, { role: "assistant", content: `Error: ${ error instanceof Error ? error.message : "Unknown error" }`, }, ]); } finally { setLoading(false); } } return (
{messages.map((m, i) => (
{m.content}
))}
setInput(e.target.value)} placeholder="Ask AI anything..." className="w-full px-4 py-2 border border-gray-500 rounded-lg" disabled={loading} />
); } ``` Next Steps [#next-steps] * Explore [Advanced Configuration](/docs/getting-started/advanced-usage) * Check the [API Reference](/docs/reference/options) for complete type definitions # OpenAI The Integrate SDK provides seamless integration with OpenAI's Responses API, allowing AI models to access your integrations through MCP tools. Installation [#installation] Install the Integrate SDK and OpenAI SDK packages: ```bash bun add integrate-sdk openai ``` Setup [#setup] Setting up OpenAI integration requires **3 files** (or **5 files** if not using a database): 1. Server Configuration [#1-server-configuration] Create a server configuration file with your OAuth credentials: ```typescript // lib/integrate.ts import { createMCPServer, githubIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); ``` 2. Providers (only if no database) [#2-providers-only-if-no-database] If you're not using a database, create a providers component that injects tokens: ```typescript // app/providers.tsx "use client"; import { client } from "integrate-sdk"; import { useIntegrateAI } from "integrate-sdk/react"; export function Providers({ children }: { children: React.ReactNode }) { useIntegrateAI(client); return <>{children}; } ``` 3. Layout (only if no database) [#3-layout-only-if-no-database] Wrap your app with the Providers component: ```typescript // app/layout.tsx import { Providers } from "./providers"; export default function RootLayout({ children, }: Readonly<{ children: React.ReactNode; }>) { return ( {children} ); } ``` 4. OAuth Handler [#4-oauth-handler] Create a catch-all route that handles OAuth operations at `app/api/integrate/[...all]/route.ts`: ```typescript import { serverClient } from "@/lib/integrate"; import { toNextJsHandler } from "integrate-sdk/server"; export const { POST, GET } = toNextJsHandler(serverClient); ``` 5. Chat API Route [#5-chat-api-route] Create a chat route that converts MCP tools to OpenAI format: ```typescript // app/api/chat/route.ts import { serverClient } from "@/lib/integrate"; import { getOpenAITools, handleOpenAIResponse } from "integrate-sdk/server"; import OpenAI from "openai"; const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY }); export async function POST(req: Request) { const { messages } = await req.json(); const response = await openai.responses.create({ model: "gpt-5-nano", input: messages, tools: await getOpenAITools(serverClient), }); const result = await handleOpenAIResponse(serverClient, response); return Response.json(result); } ``` Usage [#usage] Use OpenAI's API in any component: ```typescript // app/page.tsx "use client"; import { useState, useEffect } from "react"; import { client } from "integrate-sdk"; import { Streamdown } from "streamdown"; interface Message { role: "user" | "assistant"; content: string; } export default function ChatPage() { const [messages, setMessages] = useState([]); const [input, setInput] = useState(""); const [loading, setLoading] = useState(false); const [githubAuthorized, setGithubAuthorized] = useState(false); const isLoading = loading; useEffect(() => { client.isAuthorized("github").then(setGithubAuthorized); }, []); async function handleGithubClick() { try { if (githubAuthorized) { await client.disconnectProvider("github"); } else { await client.authorize("github"); } setGithubAuthorized(client.isAuthorized("github")); } catch (error) { console.error("Error:", error); } } function formatFunctionOutput(output: unknown): string { try { const data = typeof output === "string" ? JSON.parse(output) : output; if (data.structuredContent?.repositories) { let displayText = "\n\nπŸ“¦ **GitHub Repositories:**\n\n"; for (const repo of data.structuredContent.repositories) { displayText += `**${repo.name}**\n`; displayText += `${repo.html_url}\n`; if (repo.description) { displayText += `_${repo.description}_\n`; } displayText += `Language: ${repo.language || "N/A"} β€’ Stars: ${ repo.stargazers_count } β€’ ${repo.private ? "Private" : "Public"}\n\n`; } return displayText; } if (data.content && Array.isArray(data.content)) { let text = ""; for (const item of data.content) { if (item.type === "text" && item.text) { try { const parsed = JSON.parse(item.text); if (parsed.repositories) { let repoText = "\n\nπŸ“¦ **GitHub Repositories:**\n\n"; for (const repo of parsed.repositories) { repoText += `**${repo.name}**\n`; repoText += `${repo.html_url}\n`; if (repo.description) { repoText += `_${repo.description}_\n`; } repoText += `Language: ${repo.language || "N/A"} β€’ Stars: ${ repo.stargazers_count } β€’ ${repo.private ? "Private" : "Public"}\n\n`; } text += repoText; } else { text += JSON.stringify(parsed, null, 2); } } catch { text += item.text; } } } return text; } return JSON.stringify(data, null, 2); } catch (e) { console.error("Error formatting function output:", e); return String(output); } } async function handleSubmit(e: React.FormEvent) { e.preventDefault(); if (!input.trim()) return; const userMessage: Message = { role: "user", content: input }; setMessages((prev) => [...prev, userMessage]); setInput(""); setLoading(true); try { const response = await fetch("/api/chat", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ messages: [...messages, userMessage], }), }); if (!response.ok) { throw new Error(`HTTP error! status: ${response.status}`); } const result = await response.json(); let assistantContent = ""; const outputArray = Array.isArray(result) ? result : result.output; if (outputArray && Array.isArray(outputArray)) { for (const item of outputArray) { if (item.type === "message" && item.content) { for (const content of item.content) { if (content.type === "text" || content.type === "output_text") { assistantContent += content.text + "\n"; } } } else if (item.type === "function_call") { assistantContent += `πŸ”§ Called function: ${item.name}\n`; } else if (item.type === "function_call_output") { assistantContent += formatFunctionOutput(item.output); } } } if (!assistantContent.trim()) { assistantContent = "Response received but no displayable content found."; } setMessages((prev) => [ ...prev, { role: "assistant", content: assistantContent.trim() }, ]); } catch (error) { console.error("Error:", error); setMessages((prev) => [ ...prev, { role: "assistant", content: `Error: ${ error instanceof Error ? error.message : "Unknown error" }`, }, ]); } finally { setLoading(false); } } return (
{messages.map((m, i) => (
{m.content}
))}
setInput(e.target.value)} placeholder="Ask AI anything..." className="w-full px-4 py-2 border border-gray-500 rounded-lg" disabled={loading} />
); } ``` Next Steps [#next-steps] * Explore [Advanced Configuration](/docs/getting-started/advanced-usage) * Check the [API Reference](/docs/reference/options) for complete type definitions # Vercel AI SDK The Integrate SDK provides seamless integration with Vercel's AI SDK, allowing AI models to access your integrations through MCP tools. Installation [#installation] Install the Integrate SDK and Vercel AI SDK packages: ```bash bun add integrate-sdk ai @ai-sdk/react ``` Setup [#setup] Setting up Vercel AI integration requires **3 files** (or **5 files** if not using a database): 1. Server Configuration [#1-server-configuration] Create a server configuration file with your OAuth credentials: ```typescript // lib/integrate.ts import { createMCPServer, githubIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); ``` 2. Providers (only if no database) [#2-providers-only-if-no-database] If you're not using a database, create a providers component that injects tokens: ```typescript // app/providers.tsx "use client"; import { client } from "integrate-sdk"; import { useIntegrateAI } from "integrate-sdk/react"; export function Providers({ children }: { children: React.ReactNode }) { useIntegrateAI(client); return <>{children}; } ``` 3. Layout (only if no database) [#3-layout-only-if-no-database] Wrap your app with the Providers component: ```typescript // app/layout.tsx import { Providers } from "./providers"; export default function RootLayout({ children, }: Readonly<{ children: React.ReactNode; }>) { return ( {children} ); } ``` 4. OAuth Handler [#4-oauth-handler] Create a catch-all route that handles OAuth operations at `app/api/integrate/[...all]/route.ts`: ```typescript import { serverClient } from "@/lib/integrate"; import { toNextJsHandler } from "integrate-sdk/server"; export const { POST, GET } = toNextJsHandler(serverClient); ``` 5. Chat API Route [#5-chat-api-route] Create a chat route that converts MCP tools to Vercel AI format: ```typescript // app/api/chat/route.ts import { serverClient } from "@/lib/integrate"; import { getVercelAITools } from "integrate-sdk/server"; import { convertToModelMessages, stepCountIs, streamText } from "ai"; export async function POST(req: Request) { const { messages } = await req.json(); const result = streamText({ model: "openai/gpt-5-mini", messages: convertToModelMessages(messages), tools: await getVercelAITools(serverClient), stopWhen: stepCountIs(5), }); return result.toUIMessageStreamResponse(); } ``` Usage [#usage] Use the Vercel AI SDK's `useChat` hook in any component: ```typescript // app/page.tsx "use client"; import { useChat } from "@ai-sdk/react"; import { Streamdown } from "streamdown"; import { useState, useEffect } from "react"; import { client } from "integrate-sdk"; export default function ChatPage() { const { messages, sendMessage, status } = useChat(); const [input, setInput] = useState(""); const [githubAuthorized, setGithubAuthorized] = useState(false); const isLoading = status === "streaming"; useEffect(() => { client.isAuthorized("github").then(setGithubAuthorized); }, []); async function handleGithubClick() { try { if (githubAuthorized) { await client.disconnectProvider("github"); } else { await client.authorize("github"); } setGithubAuthorized(client.isAuthorized("github")); } catch (error) { console.error("Error:", error); } } return (
{messages.map((message) => (
{message.parts .filter((part) => part.type === "text") .map((part) => ("text" in part ? part.text : "")) .join("")}
))}
{ e.preventDefault(); if (input.trim()) { sendMessage({ text: input }); setInput(""); } }} className="p-4 border-t border-gray-500 space-y-2" > setInput(e.target.value)} placeholder="Ask me anything..." className="w-full px-4 py-2 border border-gray-500 rounded-lg" disabled={isLoading} />
); } ``` Next Steps [#next-steps] * Explore [Advanced Configuration](/docs/getting-started/advanced-usage) * Check the [API Reference](/docs/reference/options) for complete type definitions # Advanced Usage This guide covers advanced configuration options for power users who need custom client configuration and fine-grained control over connection behavior, OAuth flows, error handling, and more. Custom Client Configuration [#custom-client-configuration] For advanced use cases, you can create a custom configured client instead of using the default client: ```typescript // lib/integrate-client.ts import { createMCPClient, githubIntegration } from "integrate-sdk"; export const client = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); ``` Then import and use your custom client: ```typescript import { client } from "@/lib/integrate-client"; await client.authorize("github"); ``` Connection Modes [#connection-modes] Control when and how the client connects to the MCP server. ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const client = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], connectionMode: "lazy", }); await client.github.listOwnRepos({}); const eagerClient = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], connectionMode: "eager", }); const manualClient = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], connectionMode: "manual", }); await manualClient.connect(); await manualClient.github.listOwnRepos({}); await manualClient.disconnect(); ``` When to Use Each Mode [#when-to-use-each-mode] * **lazy** (default): Best for most use cases - connects automatically when needed * **eager**: When you want to pre-connect and cache the connection, or validate credentials early * **manual**: When you need precise control over connection lifecycle (testing, connection pooling) Singleton Pattern [#singleton-pattern] By default, `createMCPClient` returns cached instances to improve performance and reduce connections. ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const client1 = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], singleton: true, }); const client2 = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], singleton: true, }); const uniqueClient = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], singleton: false, }); ``` Clearing the Cache [#clearing-the-cache] ```typescript import { clearClientCache } from "integrate-sdk"; // Clear all cached clients and disconnect them await clearClientCache(); ``` Multi-Account Support [#multi-account-support] Connect and manage multiple accounts from the same OAuth provider (for example, multiple GitHub or Gmail accounts). Listing Connected Accounts [#listing-connected-accounts] ```typescript const accounts = await client.listAccounts("github"); // [ // { email: "work@example.com", accountId: "github_abc123", ... }, // { email: "personal@gmail.com", accountId: "github_def456", ... } // ] ``` Checking Authorization for Specific Account [#checking-authorization-for-specific-account] ```typescript // Check if any account is authorized const hasAny = await client.isAuthorized("github"); // Check if a specific account is authorized const hasWork = await client.isAuthorized("github", "work@example.com"); ``` Disconnecting a Specific Account [#disconnecting-a-specific-account] ```typescript // Disconnect a specific account by email await client.disconnectAccount("github", "work@example.com"); // Disconnect all accounts for a provider await client.disconnectProvider("github"); ``` Setting Token for a Specific Account [#setting-token-for-a-specific-account] ```typescript client.setProviderToken( "github", { accessToken: "ghp_...", tokenType: "Bearer", expiresIn: 3600, }, "work@example.com" ); ``` Auto-Cleanup [#auto-cleanup] Control whether clients automatically disconnect on process exit. ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const client = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], autoCleanup: true, }); const manualClient = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], autoCleanup: false, }); await manualClient.disconnect(); ``` Re-Authentication Handling [#re-authentication-handling] Handle expired or invalid OAuth tokens automatically. ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const client = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], onReauthRequired: async (context) => { console.log(`Re-auth needed for ${context.provider}`); console.log(`Error: ${context.error.message}`); console.log(`Tool: ${context.toolName}`); try { await client.authorize(context.provider); return true; } catch (error) { console.error("Re-auth failed:", error); return false; } }, maxReauthRetries: 1, }); try { await client.github.createIssue({ owner: "owner", repo: "repo", title: "Test issue", }); } catch (error) { console.error("Failed:", error); } ``` OAuth Flow Configuration [#oauth-flow-configuration] Customize the OAuth authorization experience. ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const client = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], oauthFlow: { mode: "popup", popupOptions: { width: 600, height: 700, }, onAuthCallback: async (provider, code, state) => { console.log(`Received callback for ${provider}`); }, }, }); ``` Popup vs Redirect [#popup-vs-redirect] **Popup Mode:** * Opens OAuth in a new window * User stays on current page * Better for single-page apps * Blocked by some browsers **Redirect Mode (default):** * Full page redirect to OAuth provider * More reliable, works everywhere * Preserves URL with `returnUrl` OAuth Configuration [#oauth-configuration] Fine-tune OAuth behavior and URLs. ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const client = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], oauthApiBase: "/api/integrate/oauth", redirectUri: "https://myapp.com/api/integrate/oauth/callback", autoHandleOAuthCallback: true, sessionToken: "existing-session-token", }); ``` OAuth Redirect URI Auto-Detection [#oauth-redirect-uri-auto-detection] **Client-side:** ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const client = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); ``` **Server-side:** ```typescript import { createMCPServer, githubIntegration } from "integrate-sdk/server"; const { client } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ clientId: process.env.GITHUB_CLIENT_ID, clientSecret: process.env.GITHUB_CLIENT_SECRET, scopes: ["repo", "user"], }), ], }); const { client: explicitClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ clientId: process.env.GITHUB_CLIENT_ID, clientSecret: process.env.GITHUB_CLIENT_SECRET, scopes: ["repo", "user"], }), ], redirectUri: process.env.OAUTH_REDIRECT_URI, }); ``` Client Information [#client-information] Customize the client identity sent to the MCP server. ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const client = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], clientInfo: { name: "my-app", version: "1.2.3", }, }); ``` HTTP Configuration [#http-configuration] Configure HTTP transport settings. ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const client = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], headers: { "X-Custom-Header": "value", "X-App-Version": "1.0.0", }, timeout: 60000, }); ``` Server-Side Configuration [#server-side-configuration] `createMCPServer` supports the same options as `createMCPClient`, plus server-specific features. ```typescript import { createMCPServer, githubIntegration } from "integrate-sdk/server"; export const { client, POST, GET } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ clientId: process.env.GITHUB_CLIENT_ID, clientSecret: process.env.GITHUB_CLIENT_SECRET, scopes: ["repo", "user"], }), ], connectionMode: "lazy", singleton: true, autoCleanup: true, timeout: 30000, redirectUri: process.env.OAUTH_REDIRECT_URI, }); export { POST, GET }; ``` Event Listeners [#event-listeners] Listen to OAuth events for custom logic. ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const client = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); client.on("auth:started", ({ provider }) => { console.log(`Starting OAuth for ${provider}`); }); client.on("auth:complete", ({ provider, accessToken, expiresAt }) => { console.log(`${provider} authorized until ${expiresAt}`); }); client.on("auth:error", ({ provider, error }) => { console.error(`Auth error for ${provider}:`, error.message); }); client.on("auth:disconnect", ({ provider }) => { console.log(`${provider} disconnected`); }); client.on("auth:logout", () => { console.log("User logged out from all services"); }); const handler = ({ provider }) => console.log(provider); client.on("auth:complete", handler); client.off("auth:complete", handler); ``` Provider Token Management [#provider-token-management] Work with provider tokens directly. ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const client = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); const githubToken = client.getProviderToken("github"); console.log(githubToken.accessToken); console.log(githubToken.expiresAt); client.setProviderToken("github", { accessToken: "ghp_...", tokenType: "Bearer", expiresIn: 3600, }); const allTokens = client.getAllProviderTokens(); await fetch("/api/ai", { method: "POST", headers: { "x-integrate-tokens": JSON.stringify(allTokens), }, body: JSON.stringify({ prompt: "Create an issue" }), }); ``` Checking Authorization [#checking-authorization] Multiple ways to check if providers are authorized. ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const client = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); const isAuthorized = await client.isAuthorized("github"); const authorized = await client.authorizedProviders(); console.log(authorized); const status = await client.getAuthorizationStatus("github"); console.log(status.authorized); console.log(status.scopes); console.log(status.expiresAt); ``` Disconnect and Logout [#disconnect-and-logout] Manage user sessions. ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const client = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); await client.disconnectProvider("github"); const isAuthorized = await client.isAuthorized("github"); await client.logout(); await client.authorize("github"); await client.authorize("gmail"); ``` Complete Example [#complete-example] Here's a comprehensive example using multiple advanced features: ```typescript import { createMCPClient, githubIntegration, gmailIntegration, } from "integrate-sdk"; const client = createMCPClient({ integrations: [ githubIntegration({ scopes: ["repo", "user"], }), gmailIntegration(), ], connectionMode: "lazy", singleton: true, autoCleanup: true, oauthFlow: { mode: "popup", popupOptions: { width: 600, height: 700 }, }, oauthApiBase: "/api/integrate/oauth", autoHandleOAuthCallback: true, onReauthRequired: async ({ provider, error }) => { console.log(`Re-auth needed for ${provider}: ${error.message}`); await client.authorize(provider); return true; }, maxReauthRetries: 2, timeout: 60000, headers: { "X-App-Version": "1.0.0", }, clientInfo: { name: "my-awesome-app", version: "1.0.0", }, }); client.on("auth:complete", ({ provider }) => { console.log(`βœ… ${provider} connected`); }); client.on("auth:error", ({ provider, error }) => { console.error(`❌ ${provider} error:`, error); }); try { await client.github.createIssue({ owner: "owner", repo: "repo", title: "Test issue", }); } catch (error) { console.error("Failed to create issue:", error); } ``` Next Steps [#next-steps] * Learn about [OAuth Setup in Next.js](/docs/frameworks/frontend/nextjs) * Integrate with [Vercel AI SDK](/docs/artificial-intelligence/vercel-ai-sdk) * Check the [API Reference](/docs/reference/options) for complete type definitions # Basic Usage **For AI agents:** Start with the Markdown entry point at [`/llms.txt`](/llms.txt). This page is also available at [`/docs/getting-started/basic-usage.mdx`](/docs/getting-started/basic-usage.mdx). Server Configuration [#server-configuration] First, create a server configuration file with your OAuth credentials: ```typescript // lib/integrate.ts import { createMCPServer, githubIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ clientId: process.env.GITHUB_CLIENT_ID, clientSecret: process.env.GITHUB_CLIENT_SECRET, scopes: ["repo", "user"], }), ], }); ``` You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). Client Usage [#client-usage] The client is automatically configured when making requests to the server. Here's a complete example that calls a GitHub tool: ```typescript import { client } from "integrate-sdk"; if (!(await client.isAuthorized("github"))) { await client.authorize("github"); } const result = await client.github.createIssue({ owner: "owner", repo: "repo", title: "Bug report", body: "Description of the bug", }); console.log("Issue created:", result); ``` Client-Side vs Server-Side [#client-side-vs-server-side] The SDK works in both browser and Node.js environments, but with different capabilities: Browser Environment βœ… [#browser-environment-] * Full OAuth authorization UI (popup/redirect) * Make API calls to integrated services * Complete session management Server Environment πŸ–₯️ [#server-environment-️] * Make API calls with provider access tokens * No OAuth UI (throws error if attempted) * Perfect for backend API routes ```typescript import { client } from "integrate-sdk"; client.setProviderToken("github", { accessToken: userAccessToken, tokenType: "Bearer", expiresIn: 3600, }); const repos = await client.github.listRepos({ username: "octocat" }); await client.authorize("github"); ``` πŸ’‘ **Tip:** Handle OAuth authorization in the browser, then store the access token in your database for backend API calls. Step-by-Step Breakdown [#step-by-step-breakdown] 1. Import the SDK [#1-import-the-sdk] ```typescript import { client } from "integrate-sdk"; ``` 2. Set Up OAuth Credentials [#2-set-up-oauth-credentials] Before using the SDK, you need to create OAuth apps for the services you want to integrate: * **GitHub**: Create an OAuth App at [GitHub Developer Settings](https://github.com/settings/developers) * **Gmail**: Create a project and OAuth 2.0 credentials in [Google Cloud Console](https://console.cloud.google.com) Store your credentials in environment variables: ```bash INTEGRATE_API_KEY=your_integrate_api_key GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret GMAIL_CLIENT_ID=your_gmail_client_id GMAIL_CLIENT_SECRET=your_gmail_client_secret ``` 3. Call Tools [#3-call-tools] ```typescript import { client } from "integrate-sdk"; const result = await client.github.createIssue({ owner: "owner", repo: "repo", title: "Bug report", body: "Description of the bug", }); ``` List Available Tools [#list-available-tools] To see what tools are available from the server: ```typescript import { client } from "integrate-sdk"; const tools = await client.getEnabledToolsAsync(); console.log( "Available tools:", tools.map((t) => t.name) ); ``` `getEnabledTools()` returns only tools already cached locally. Use `getEnabledToolsAsync()` when you need fresh tool metadata from the server. Error Handling [#error-handling] Wrap your code in try-catch blocks to handle errors: ```typescript import { client } from "integrate-sdk"; try { const result = await client.github.createIssue({ owner: "owner", repo: "repo", title: "Bug report", }); console.log("Success:", result); } catch (error) { console.error("Error:", error.message); } ``` Next Steps [#next-steps] * Learn about [OAuth authorization](/docs/getting-started/basic-usage) to handle user authentication * Explore [Built-in Integrations](/docs/integrations) to see what integrations are available * Check out [Advanced Usage](/docs/getting-started/advanced-usage) for re-authentication, error handling, and more * Integrate with [Vercel AI SDK](/docs/artificial-intelligence/vercel-ai-sdk) to give AI models access to your tools # Database This page has moved to the [Database](/docs/database) section. * [Overview](/docs/database) * [Drizzle adapter](/docs/database/drizzle) * [Prisma adapter](/docs/database/prisma) * [MongoDB adapter](/docs/database/mongodb) * [Schema reference](/docs/database/schema) * [Triggers](/docs/database/triggers) * [Hooks](/docs/database/hooks) * [Examples](https://github.com/integratedotdev/examples/tree/main/database): Drizzle, Prisma, and MongoDB Next.js apps * [MCP tool scoping](/docs/guides/mcp-tool-scoping): `connectedOnly`, `integrationIds`, Code Mode * [Performance](/docs/guides/performance): caching, concurrency, cold start For manual callback configuration (without adapters), see [Schema](/docs/database/schema) and the callback signatures in the [Database overview](/docs/database). # Installation import { Tabs, Tab } from "fumadocs-ui/components/tabs"; Install the Integrate SDK using your preferred package manager. ```bash bun add integrate-sdk ``` ```bash npm install integrate-sdk ``` ```bash pnpm add integrate-sdk ``` ```bash yarn add integrate-sdk ``` TypeScript Support [#typescript-support] The SDK is built with TypeScript and includes type definitions out of the box. No additional `@types` packages are needed. Requirements [#requirements] * Node.js 20.9+ or newer * TypeScript 5.6+ (for TypeScript projects) * `integrate-sdk` **0.10.0+** (Google integrations use `google_*` ids; see [migration note](#google-integration-ids-v0100) below) Google integration ids (v0.10.0+) [#google-integration-ids-v0100] In **0.10.0**, short Google integration ids were renamed to `google_*` for consistency with blob assets and docs URLs. `gmail` is unchanged. | Before (≀0.9.x) | Now (0.10.0+) | | --------------- | ------------------ | | `gcal` | `google_calendar` | | `gchat` | `google_chat` | | `gcontacts` | `google_contacts` | | `gdocs` | `google_docs` | | `gdrive` | `google_drive` | | `gkeep` | `google_keep` | | `gmeet` | `google_meet` | | `gsheets` | `google_sheets` | | `gslides` | `google_slides` | | `gtasks` | `google_tasks` | | `ga4` | `google_analytics` | Update integration factories (`googleCalendarIntegration()`), client namespaces (`client.google_calendar`), env vars (`GOOGLE_CALENDAR_CLIENT_ID`), and tool names (`google_calendar_list_events`) when upgrading. Examples [#examples] Browse runnable projects for frameworks, database adapters, and AI SDKs in the [Integrate examples repository](https://github.com/integratedotdev/examples). Frontend and database examples use Next.js by default; backend examples cover Express, Hono, Fastify, and more. Next Steps [#next-steps] Now that you have the SDK installed, check out the [Basic Usage](/docs/getting-started/basic-usage) guide to create your first integration. # Triggers Triggers allow you to schedule tool executions for a specific time or on a recurring schedule. This enables use cases like sending scheduled emails, daily reports, automated reminders, and AI agents that schedule actions for later. Triggers are created and managed **in your application** via `createMCPServer` trigger callbacks or the [database adapter](/docs/database/triggers). The Integrate hosted dashboard is for API keys, billing, and usage, not for creating triggers on behalf of your users. Overview [#overview] Triggers are stored in your database and executed by the MCP server scheduler. When a trigger fires, the MCP server calls your Next.js API to get the trigger details and OAuth token, executes the tool, and reports the result back. Architecture [#architecture] ``` Browser β†’ Next.js API β†’ Your Database (trigger storage) ↓ MCP Server Scheduler (execution) ``` Setup [#setup] 1. Configure Database Callbacks [#1-configure-database-callbacks] Add trigger storage callbacks to your server configuration. The SDK pre-processes trigger data before calling your callbacks, so you only need to handle database operations: ```typescript // lib/integrate-server.ts import { createMCPServer, githubIntegration, gmailIntegration } from "integrate-sdk/server"; import { db } from "./db"; // Your database client export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ clientId: process.env.GITHUB_CLIENT_ID, clientSecret: process.env.GITHUB_CLIENT_SECRET, }), gmailIntegration({ clientId: process.env.GMAIL_CLIENT_ID, clientSecret: process.env.GMAIL_CLIENT_SECRET, }), ], // Trigger storage callbacks triggers: { // SDK pre-processes: generates ID (trig_xxx), extracts provider, sets status='active', timestamps create: async (trigger, context) => { // trigger already has: id, provider, status, createdAt, updatedAt return db.trigger.create({ data: { ...trigger, userId: context?.userId }, }); }, get: async (triggerId, context) => { return db.trigger.findFirst({ where: { id: triggerId, userId: context?.userId }, }); }, // SDK calculates hasMore from your response list: async (params, context) => { const [triggers, total] = await Promise.all([ db.trigger.findMany({ where: { userId: context?.userId, status: params.status, toolName: params.toolName, }, take: params.limit || 20, skip: params.offset || 0, }), db.trigger.count({ where: { userId: context?.userId, status: params.status, toolName: params.toolName, }, }), ]); // Return triggers and total - SDK calculates hasMore automatically return { triggers, total, }; }, // SDK sets updatedAt automatically on updates update: async (triggerId, updates, context) => { return db.trigger.update({ where: { id: triggerId, userId: context?.userId }, data: updates, }); }, delete: async (triggerId, context) => { await db.trigger.delete({ where: { id: triggerId, userId: context?.userId }, }); }, }, }); ``` SDK Pre-processing [#sdk-pre-processing] The SDK automatically handles the following before calling your callbacks: * **ID Generation**: Generates unique IDs in format `trig_{12-character-nanoid}` (e.g., `trig_abc123xyz789`) * **Provider Extraction**: Extracts provider from tool name (e.g., `gmail_send_email` β†’ `gmail`) * **Status Defaults**: Sets `status: 'active'` if not provided * **Timestamps**: Sets `createdAt` and `updatedAt` on create, `updatedAt` on update/pause/resume * **Status Validation**: Validates pause/resume transitions (only active β†’ paused, paused β†’ active) * **Pagination**: Calculates `hasMore` flag from your `{triggers, total}` response Your callbacks are thin database wrappers - just insert/update/query your database. 2. Database Schema [#2-database-schema] Create a triggers table in your database with the following fields: ```sql CREATE TABLE triggers ( id VARCHAR(255) PRIMARY KEY, name VARCHAR(255), description TEXT, tool_name VARCHAR(255) NOT NULL, tool_arguments JSON NOT NULL, schedule_type VARCHAR(50) NOT NULL, schedule_value TEXT NOT NULL, status VARCHAR(50) DEFAULT 'active', created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, last_run_at TIMESTAMP, next_run_at TIMESTAMP, run_count INT DEFAULT 0, last_error TEXT, last_result JSON, user_id VARCHAR(255), provider VARCHAR(50) ); CREATE INDEX idx_triggers_user ON triggers(user_id); CREATE INDEX idx_triggers_status ON triggers(status); ``` For Prisma: ```prisma model Trigger { id String @id name String? description String? toolName String @map("tool_name") toolArguments Json @map("tool_arguments") scheduleType String @map("schedule_type") scheduleValue String @map("schedule_value") status String @default("active") createdAt DateTime @default(now()) @map("created_at") updatedAt DateTime @updatedAt @map("updated_at") lastRunAt DateTime? @map("last_run_at") nextRunAt DateTime? @map("next_run_at") runCount Int @default(0) @map("run_count") lastError String? @map("last_error") lastResult Json? @map("last_result") userId String? @map("user_id") provider String? @@index([userId]) @@index([status]) @@map("triggers") } ``` Usage [#usage] Creating Triggers [#creating-triggers] One-Time Trigger [#one-time-trigger] Schedule a tool execution for a specific date and time: ```typescript import { client } from "integrate-sdk"; // Send an email at a specific time const trigger = await client.trigger.create({ name: "Follow-up Email", toolName: "gmail_send_email", toolArguments: { to: "friend@example.com", subject: "About the dog", body: "Hey, just wanted to follow up about the dog...", }, schedule: { type: "once", runAt: new Date("2024-12-13T22:00:00Z"), }, }); console.log("Trigger created:", trigger.id); ``` Recurring Trigger [#recurring-trigger] Schedule a tool execution on a recurring basis using cron expressions: ```typescript // Daily standup reminder at 9 AM on weekdays const standup = await client.trigger.create({ name: "Daily Standup Reminder", description: "Remind team about daily standup", toolName: "slack_send_message", toolArguments: { channel: "#engineering", text: "Time for standup! πŸš€", }, schedule: { type: "cron", expression: "0 9 * * 1-5", // 9 AM Monday-Friday }, }); ``` Common cron expressions: * `0 9 * * *` - Every day at 9:00 AM * `0 9 * * 1-5` - Weekdays at 9:00 AM * `0 */2 * * *` - Every 2 hours * `0 0 1 * *` - First day of every month at midnight * `0 0 * * 0` - Every Sunday at midnight Listing Triggers [#listing-triggers] Get all triggers or filter by status. The SDK automatically calculates `hasMore` for pagination: ```typescript // Get all active triggers const { triggers, total, hasMore } = await client.trigger.list({ status: "active", limit: 20, offset: 0, }); console.log(`Found ${total} active triggers`); console.log(`Has more: ${hasMore}`); // SDK calculates this automatically triggers.forEach((trigger) => { console.log(`- ${trigger.name}: ${trigger.status}`); }); // Filter by tool name const emailTriggers = await client.trigger.list({ toolName: "gmail_send_email", }); // Pagination example let offset = 0; const limit = 20; let hasMore = true; while (hasMore) { const result = await client.trigger.list({ offset, limit }); console.log(`Page ${offset / limit + 1}: ${result.triggers.length} triggers`); hasMore = result.hasMore; offset += limit; } ``` **Note**: Your `list` callback should return `{triggers, total}` - the SDK calculates `hasMore` automatically from the offset, returned count, and total. Getting a Trigger [#getting-a-trigger] Retrieve a specific trigger by ID: ```typescript const trigger = await client.trigger.get("trig_abc123"); console.log("Trigger:", trigger.name); console.log("Status:", trigger.status); console.log("Next run:", trigger.nextRunAt); console.log("Run count:", trigger.runCount); ``` Updating Triggers [#updating-triggers] Update trigger properties like arguments or schedule: ```typescript // Update the schedule await client.trigger.update("trig_abc123", { schedule: { type: "cron", expression: "0 10 * * 1-5", // Changed to 10 AM }, }); // Update the tool arguments await client.trigger.update("trig_abc123", { toolArguments: { channel: "#general", text: "Updated message", }, }); // Update name and description await client.trigger.update("trig_abc123", { name: "Updated Name", description: "New description", }); ``` Pausing and Resuming [#pausing-and-resuming] Temporarily stop a trigger without deleting it. The SDK validates status transitions automatically: ```typescript // Pause a trigger (stops future executions) // Only works if trigger status is 'active' await client.trigger.pause("trig_abc123"); // Resume a paused trigger // Only works if trigger status is 'paused' await client.trigger.resume("trig_abc123"); // Invalid transitions return an error: // - Cannot pause a trigger that's already paused, completed, or failed // - Cannot resume a trigger that's not paused ``` The SDK automatically: * Validates the current status before allowing pause/resume * Sets `updatedAt` timestamp on status changes * Returns descriptive error messages for invalid transitions Manual Execution [#manual-execution] Execute a trigger immediately, bypassing the schedule: ```typescript const result = await client.trigger.run("trig_abc123"); if (result.success) { console.log("Execution successful:", result.result); } else { console.error("Execution failed:", result.error); } console.log("Duration:", result.duration, "ms"); ``` Deleting Triggers [#deleting-triggers] Permanently delete a trigger: ```typescript await client.trigger.delete("trig_abc123"); ``` AI Agent Integration [#ai-agent-integration] Triggers are perfect for AI agents that need to schedule actions based on natural language requests: ```typescript async function handleAIRequest(userMessage: string) { // AI processes: "Send an email about the dog on December 13 at 10 PM" const parsed = await ai.parse(userMessage); if (parsed.intent === "schedule_email") { const trigger = await client.trigger.create({ toolName: "gmail_send_email", toolArguments: { to: parsed.recipient, subject: parsed.subject, body: parsed.body, }, schedule: { type: "once", runAt: parsed.scheduledTime, // "2024-12-13T22:00:00Z" }, }); return `I've scheduled the email to be sent on ${parsed.scheduledTime}`; } } ``` Advanced Usage [#advanced-usage] Multi-Tenant Support [#multi-tenant-support] Use the context parameter to isolate triggers by user: ```typescript // Server configuration with user context export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [...], // Extract user ID from session getSessionContext: async (request) => { const session = await getSession(request); return { userId: session.userId }; }, triggers: { create: async (trigger, context) => { // context.userId is automatically provided return db.trigger.create({ data: { ...trigger, userId: context?.userId }, }); }, // ... other callbacks }, }); ``` Error Handling [#error-handling] Handle trigger execution errors: ```typescript const { triggers } = await client.trigger.list({ status: "failed" }); for (const trigger of triggers) { console.log(`Trigger ${trigger.name} failed:`); console.log(`Error: ${trigger.lastError}`); console.log(`Last attempt: ${trigger.lastRunAt}`); // Optionally retry try { await client.trigger.run(trigger.id); } catch (error) { console.error("Retry failed:", error); } } ``` Monitoring [#monitoring] Track trigger execution history: ```typescript const trigger = await client.trigger.get("trig_abc123"); console.log("Execution stats:"); console.log(`- Total runs: ${trigger.runCount}`); console.log(`- Last run: ${trigger.lastRunAt}`); console.log(`- Next run: ${trigger.nextRunAt}`); console.log(`- Status: ${trigger.status}`); if (trigger.lastResult) { console.log("Last result:", trigger.lastResult); } if (trigger.lastError) { console.error("Last error:", trigger.lastError); } ``` Type Definitions [#type-definitions] Trigger [#trigger] ```typescript interface Trigger { id: string; name?: string; description?: string; toolName: string; toolArguments: Record; schedule: TriggerSchedule; status: "active" | "paused" | "completed" | "failed"; createdAt: string; updatedAt: string; lastRunAt?: string; nextRunAt?: string; runCount?: number; lastError?: string; lastResult?: Record; userId?: string; provider?: string; } ``` TriggerSchedule [#triggerschedule] ```typescript type TriggerSchedule = | { type: "once"; runAt: string | Date } | { type: "cron"; expression: string }; ``` CreateTriggerInput [#createtriggerinput] ```typescript interface CreateTriggerInput { name?: string; description?: string; toolName: string; toolArguments: Record; schedule: TriggerSchedule; status?: "active" | "paused" | "completed" | "failed"; // Optional, defaults to 'active' } ``` **Note**: The SDK pre-processes this input before calling your `create` callback. Your callback receives a fully processed `Trigger` object with: * Generated `id` (format: `trig_{nanoid}`) * Extracted `provider` from `toolName` * Default `status: 'active'` if not provided * `createdAt` and `updatedAt` timestamps TriggerExecutionResult [#triggerexecutionresult] ```typescript interface TriggerExecutionResult { success: boolean; result?: Record; error?: string; executedAt: string; duration?: number; } ``` SDK Pre-processing Details [#sdk-pre-processing-details] The SDK handles all trigger data pre-processing, making your callbacks simple database operations: What the SDK Pre-processes [#what-the-sdk-pre-processes] **On Create:** * Generates unique ID: `trig_{12-character-nanoid}` (e.g., `trig_abc123xyz789`) * Extracts provider from tool name: `gmail_send_email` β†’ `gmail` * Sets default status: `'active'` if not provided * Sets timestamps: `createdAt` and `updatedAt` to current time **On Update:** * Automatically sets `updatedAt` timestamp **On Pause/Resume:** * Validates status transitions: * Pause: Only allows `active` β†’ `paused` * Resume: Only allows `paused` β†’ `active` * Sets `updatedAt` timestamp * Returns descriptive errors for invalid transitions **On List:** * Calculates `hasMore` flag: `(offset + triggers.length) < total` * Your callback only needs to return `{triggers, total}` Benefits [#benefits] * **Consistent IDs**: All triggers use the same nanoid-based format * **Less Code**: No need to generate IDs or extract providers in your callbacks * **Type Safety**: Fully typed trigger objects throughout * **Validation**: Status transitions validated before database calls * **Simpler Callbacks**: Focus on database operations only Best Practices [#best-practices] Use Descriptive Names [#use-descriptive-names] Give your triggers meaningful names for easier management: ```typescript await client.trigger.create({ name: "Weekly Sales Report - Mondays 9 AM", description: "Send sales report to team@company.com", // ... }); ``` Handle Timezone Differences [#handle-timezone-differences] When creating one-time triggers, ensure you're using the correct timezone: ```typescript // Use UTC timestamps const utcTime = new Date("2024-12-13T22:00:00Z"); // Or convert from local time const localTime = new Date("2024-12-13T14:00:00"); // 2 PM local const utcTime = new Date(localTime.toISOString()); await client.trigger.create({ schedule: { type: "once", runAt: utcTime }, // ... }); ``` Clean Up Completed Triggers [#clean-up-completed-triggers] Remove one-time triggers after they complete: ```typescript const { triggers } = await client.trigger.list({ status: "completed" }); for (const trigger of triggers) { // Keep for audit or delete immediately await client.trigger.delete(trigger.id); } ``` Test Before Scheduling [#test-before-scheduling] Use manual execution to test triggers before scheduling: ```typescript // Create trigger with paused status (SDK accepts custom status) const trigger = await client.trigger.create({ name: "Test Email", toolName: "gmail_send_email", toolArguments: { /* ... */ }, schedule: { type: "cron", expression: "0 9 * * *" }, status: "paused", // Create as paused to prevent automatic execution }); // Test execution const result = await client.trigger.run(trigger.id); if (result.success) { // Resume if test passed (SDK validates status transition) await client.trigger.resume(trigger.id); } else { console.error("Test failed:", result.error); // Keep paused or delete } ``` **Note**: The SDK validates that you can only resume triggers with status `'paused'`. If you create a trigger with a different status, you'll need to handle transitions appropriately. Troubleshooting [#troubleshooting] Trigger Not Executing [#trigger-not-executing] 1. **Check trigger status**: Ensure it's `active`, not `paused` 2. **Verify schedule**: Check `nextRunAt` to see when it will execute 3. **Check OAuth token**: Ensure the provider is authorized 4. **Review errors**: Check `lastError` for execution failures ```typescript const trigger = await client.trigger.get("trig_abc123"); if (trigger.status === "paused") { // SDK validates status - only resumes if status is 'paused' await client.trigger.resume(trigger.id); } else if (trigger.status === "failed") { // Failed triggers cannot be resumed directly // You may need to update status or create a new trigger console.error("Trigger failed:", trigger.lastError); } if (trigger.lastError) { console.error("Last error:", trigger.lastError); } ``` Status Transition Errors [#status-transition-errors] If you get errors when pausing or resuming, check the trigger's current status: ```typescript try { await client.trigger.pause("trig_abc123"); } catch (error) { // Error message will indicate why pause failed: // - "Cannot pause trigger with status 'paused'" // - "Cannot pause trigger with status 'completed'" // - etc. console.error("Pause failed:", error.message); const trigger = await client.trigger.get("trig_abc123"); console.log("Current status:", trigger.status); } ``` OAuth Token Expired [#oauth-token-expired] If a trigger fails due to expired tokens, the user needs to re-authorize: ```typescript const trigger = await client.trigger.get("trig_abc123"); if (trigger.provider) { const isAuthorized = await client.isAuthorized(trigger.provider); if (!isAuthorized) { console.log("Re-authorization required for", trigger.provider); await client.authorize(trigger.provider); } } ``` Invalid Cron Expression [#invalid-cron-expression] Validate cron expressions before creating triggers: ```typescript function isValidCron(expression: string): boolean { // Basic validation - 5 parts (minute, hour, day, month, weekday) const parts = expression.split(" "); return parts.length === 5; } const cronExpression = "0 9 * * 1-5"; if (!isValidCron(cronExpression)) { throw new Error("Invalid cron expression"); } await client.trigger.create({ schedule: { type: "cron", expression: cronExpression }, // ... }); ``` Examples [#examples] Daily Summary Email [#daily-summary-email] ```typescript await client.trigger.create({ name: "Daily Summary Email", description: "Send daily summary at 6 PM", toolName: "gmail_send_email", toolArguments: { to: "team@company.com", subject: "Daily Summary - {{date}}", body: "Today's summary...", }, schedule: { type: "cron", expression: "0 18 * * *", // 6 PM daily }, }); ``` Weekly GitHub Issue Reminder [#weekly-github-issue-reminder] ```typescript await client.trigger.create({ name: "Weekly Issue Review", description: "Remind team to review open issues", toolName: "slack_send_message", toolArguments: { channel: "#engineering", text: "πŸ“‹ Time to review open GitHub issues!", }, schedule: { type: "cron", expression: "0 10 * * 1", // Mondays at 10 AM }, }); ``` Birthday Email [#birthday-email] ```typescript await client.trigger.create({ name: "Birthday Email for John", toolName: "gmail_send_email", toolArguments: { to: "john@company.com", subject: "Happy Birthday! πŸŽ‰", body: "Wishing you a wonderful birthday!", }, schedule: { type: "once", runAt: new Date("2024-06-15T09:00:00Z"), }, }); ``` # MCP Tool Scoping Integrate uses three independent layers to scope MCP tools. Understanding them prevents slow tool discovery and models seeing tools the user cannot use. The three layers [#the-three-layers] | Layer | Mechanism | Controls | | ---------------------- | ------------------------------------------------------------------ | ------------------------------------------ | | **Integration config** | Integrations passed to `createMCPServer` + `X-Integrations` header | Which tool *definitions* exist in your app | | **OAuth tokens** | `getProviderToken(provider, email, context)` on each `tools/call` | Whether a tool *executes* for a user | | **API key** | `apiKey` on server config β†’ `X-API-Key` on MCP requests | Billing, rate limits, usage `userId` | Listing is **config-based** by default: if Gmail is in your server config, Gmail tools appear even when the user has not connected Gmail. Execution fails without a token. Connected-only tool loading [#connected-only-tool-loading] Use `connectedOnly` when building AI tools for a signed-in user so you only fetch schemas for integrations they have OAuth tokens for: ```typescript import { getVercelAITools } from "integrate-sdk/server"; import { serverClient } from "@/lib/integrate"; const tools = await getVercelAITools(serverClient, { context: { userId: session.user.id }, connectedOnly: true, mode: "code", }); ``` This calls `getProviderToken` per configured integration (via your database adapter or callbacks) and only runs `list_tools_by_integration` for providers with usable tokens. Manual integration filter [#manual-integration-filter] Pass an explicit allowlist when you already know which providers to expose: ```typescript const tools = await getVercelAITools(serverClient, { integrationIds: ["github", "gmail", "slack"], context: { userId }, }); ``` Or on the client directly: ```typescript const mcpTools = await serverClient.getEnabledToolsAsync({ integrationIds: ["github"], context: { userId }, }); ``` listConnectedProviders helper [#listconnectedproviders-helper] For custom logic (routing, UI badges, background jobs), use the exported helper: ```typescript import { listConnectedProviders } from "integrate-sdk/server"; const connected = await listConnectedProviders( ["github", "gmail", "slack"], (provider, email, context) => serverClient.getProviderToken(provider, email, context), { userId: session.user.id } ); ``` With a database adapter, `getProviderToken` is already wired. You can also derive connected providers from token rows using `listConnectedProvidersFromRows`. Code Mode + scoping [#code-mode--scoping] [Code Mode](/docs/artificial-intelligence/code-mode) collapses hundreds of MCP tools into `execute_code` + `get_types`, which dramatically reduces context size. Pair it with `connectedOnly` so cold-start discovery only hits integrations the user has connected: ```typescript const tools = await getVercelAITools(serverClient, { context: { userId }, connectedOnly: true, mode: "code", }); ``` Set `codeMode.publicUrl` or `INTEGRATE_URL` so Code Mode can call back into `/api/integrate/mcp`. Triggers and automations [#triggers-and-automations] Scheduled work belongs in **your application database**, not the Integrate platform dashboard. Configure `triggers` callbacks or the [database adapter](/docs/database) in your app; the MCP scheduler calls your `/api/integrate/triggers/notify` route. The hosted dashboard at integrate.dev is for API keys, billing, and usage, not for creating triggers on behalf of your users. Related [#related] * [Performance](/docs/guides/performance): caching and concurrency * [Database adapters](/docs/database): token storage and `connectedOnly` * [Triggers](/docs/getting-started/triggers): SDK trigger callbacks # Native Automations with SDK Primitives Production apps like [Individu](https://github.com/integratedotdev/individu) often outgrow SDK-managed trigger CRUD but still rely on integrate-sdk for the hard parts: OAuth tokens, MCP tool execution, and multi-step callbacks. When to use what [#when-to-use-what] | Pattern | Use when | | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------- | | **SDK triggers** (`triggers.onComplete`, `serverClient.trigger.*`) | You want scheduler registration + CRUD handled by the SDK | | **Native orchestration** | You own scheduling (cron, queues, Vercel cron) but call MCP tools server-side | | **Hybrid** | Legacy SDK triggers + new native automations; share `onComplete` for multi-step flows | Server-side tool execution [#server-side-tool-execution] Use the public `callTool` API (not `_callToolByName`): ```typescript import { serverClient } from "@/lib/integrate"; import { parseMCPToolResult } from "integrate-sdk/server"; const raw = await serverClient.callTool("github_list_repos", { per_page: 10 }, { context: { userId }, }); const result = parseMCPToolResult(raw); if (!result.ok) { throw new Error(result.error); } ``` `parseMCPToolResult` normalizes MCP `isError`, `success: false`, `structuredContent`, and text `content` blocks. Multi-step orchestration (onComplete) [#multi-step-orchestration-oncomplete] Wire SDK trigger callbacks when steps should chain: ```typescript createMCPServer({ // ... triggers: { onComplete: async (ctx) => { // ctx.request.steps: normalize with parseMCPToolResult per step // return { hasMore, nextStep } for chained execution return { hasMore: false }; }, getCallbackUrl: () => process.env.APP_URL!, }, }); ``` Types: `StepResult`, `CompleteCallbackContext`, `CompleteResponse` from `integrate-sdk`. Template variables between steps [#template-variables-between-steps] Resolve outputs from prior steps in your orchestrator (see Individu's `lib/automations/template.ts` pattern). Keep templates in your app; the SDK provides execution + result parsing only. Performance for automation agents [#performance-for-automation-agents] Reuse cached AI tools across chat and automation paths: ```typescript import { getVercelAITools } from "integrate-sdk/server"; import { createMemoryToolDiscoveryCache } from "integrate-sdk/server"; const cache = createMemoryToolDiscoveryCache(); const tools = await getVercelAITools(serverClient, { context: { userId }, connectedOnly: true, mode: "code", cache: { cache, ttlMs: 5 * 60 * 1000 }, }); ``` Invalidate on OAuth connect/disconnect via `createToolDiscoveryCacheInvalidator(cache)` in your database adapter `onTokenChange` hook. # Performance Cold-start tool discovery is the most common performance issue in production apps with many integrations. This guide covers patterns that keep chat and automation startup fast. Problem: N integrations Γ— network round-trips [#problem-n-integrations--network-round-trips] `getEnabledToolsAsync()` fetches tool schemas via `list_tools_by_integration` once per configured integration. With 100+ integrations and concurrency 8, a cold serverless instance can still take several seconds before the first chat turn. Mitigations (use together): 1. **`connectedOnly: true`**: only fetch integrations the user has OAuth tokens for 2. **`mode: 'code'`**: expose 2 AI tools instead of hundreds ([Code Mode](/docs/artificial-intelligence/code-mode)) 3. **`hydrateToolCache`**: skip network discovery when metadata is already known 4. **Raise `fetchConcurrency`** when you must fetch many integrations at once Connected-only discovery [#connected-only-discovery] ```typescript await serverClient.getEnabledToolsAsync({ connectedOnly: true, context: { userId }, fetchConcurrency: 8, // default in v0.10.0+ }); ``` For AI helpers: ```typescript await getVercelAITools(serverClient, { context: { userId }, connectedOnly: true, mode: "code", }); ``` Invalidate your app-level cache when tokens change (OAuth connect/disconnect). Built-in tool discovery cache (v0.10.0+) [#built-in-tool-discovery-cache-v0100] Pass a `cache` adapter to `getVercelAITools` instead of hand-rolling Redis + `hydrateToolCache`: ```typescript import { getVercelAITools, createMemoryToolDiscoveryCache, createToolDiscoveryCacheInvalidator, } from "integrate-sdk/server"; const cache = createMemoryToolDiscoveryCache(); const tools = await getVercelAITools(serverClient, { context: { userId }, connectedOnly: true, mode: "code", cache: { cache, ttlMs: 5 * 60 * 1000 }, }); // In drizzleAdapter onTokenChange: createToolDiscoveryCacheInvalidator(cache)({ userId }); ``` Implement `ToolDiscoveryCacheAdapter` for Redis (see production Next.js guide). Keys default to `userId:provider1,provider2`. hydrateToolCache for serverless [#hydratetoolcache-for-serverless] The SDK exposes `hydrateToolCache` on the server client so you can restore tool metadata without per-integration fetches: ```typescript // After a previous discovery pass, persist stubs (name, description, inputSchema) serverClient.hydrateToolCache(cachedStubs); // Subsequent getEnabledToolsAsync / getVercelAITools calls use the cache const tools = await getVercelAITools(serverClient, { context: { userId }, connectedOnly: true, }); ``` **Production pattern:** persist stubs in Redis keyed by `userId` (and connected-provider set). On cold start, hydrate before calling `getVercelAITools`. Clear the cache when `onTokenChange` fires from your database adapter. Include connected providers in your cache key so reconnecting OAuth invalidates stale tool lists: ```typescript const cacheKey = `${userId}:${connectedProviders.sort().join(",")}`; ``` Code Mode default [#code-mode-default] Code Mode still runs discovery internally, but the model only receives `execute_code` and `get_types`. Always set `codeMode.publicUrl` or `INTEGRATE_URL` on the server: ```typescript createMCPServer({ codeMode: { publicUrl: process.env.INTEGRATE_URL }, // ... }); ``` Usage tracking [#usage-tracking] Tool calls must include your server `apiKey` so the MCP server can attribute usage to the correct customer. Ensure: * `INTEGRATE_API_KEY` is set in your app (server-only) * Your dashboard `/api/usage` route is reachable from the MCP server (no auth session redirect) * `MCP_SERVER_SECRET` matches between MCP server and dashboard * `APP_BASE_URL` on the MCP server points at your dashboard origin See your dashboard `ENV_SETUP.md` for the full usage pipeline. Related [#related] * [MCP Tool Scoping](/docs/guides/mcp-tool-scoping) * [Code Mode](/docs/artificial-intelligence/code-mode) * [Database hooks](/docs/database/hooks): `onTokenChange` for cache invalidation # Production Next.js App This guide summarizes patterns proven in production apps using integrate-sdk with Next.js App Router, session-based auth, and Vercel AI SDK. Server setup [#server-setup] ```typescript // lib/integrate.ts import { createMCPServer, createIntegrationBundle, createMemoryToolDiscoveryCache, createToolDiscoveryCacheInvalidator, } from "integrate-sdk/server"; import { drizzleAdapter } from "integrate-sdk/adapters/drizzle"; import { db } from "@/database"; import { providerToken, trigger } from "@/database/schema"; const toolDiscoveryCache = createMemoryToolDiscoveryCache(); export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY!, apiBaseUrl: process.env.APP_URL, codeMode: { publicUrl: process.env.INTEGRATE_URL ?? process.env.APP_URL }, integrations: createIntegrationBundle({ include: ["github", "gmail", "slack"] }), enabledProviders: ["github", "gmail", "slack"], database: drizzleAdapter(db, { provider: "pg", schema: { providerToken, trigger }, hooks: { onTokenChange: ({ userId }) => { void toolDiscoveryCache.invalidate(userId); }, }, }), getSessionContext: async (req) => { const session = await auth.api.getSession({ headers: req.headers }); return session?.user?.id ? { userId: session.user.id } : undefined; }, triggers: { onComplete: handleTriggerCompletion, getCallbackUrl: () => process.env.APP_URL!, }, }); ``` Route handler [#route-handler] ```typescript // app/api/integrate/[...all]/route.ts import { serverClient } from "@/lib/integrate"; import { toNextJsHandler } from "integrate-sdk/server"; export const maxDuration = 300; export const { POST, GET } = toNextJsHandler(serverClient); ``` Tool name normalization runs inside the SDK handler. No app-level POST wrapper is required. AI chat tools [#ai-chat-tools] ```typescript import { getVercelAITools } from "integrate-sdk/server"; import { serverClient } from "@/lib/integrate"; const tools = await getVercelAITools(serverClient, { context: { userId: session.user.id }, connectedOnly: true, mode: "code", cache: { cache: toolDiscoveryCache, ttlMs: 300_000 }, }); ``` See [Performance](/docs/guides/performance) and [MCP Tool Scoping](/docs/guides/mcp-tool-scoping). Browser OAuth UI [#browser-oauth-ui] ```tsx "use client"; import { client } from "integrate-sdk"; import { useIntegrateAuth } from "integrate-sdk/react"; function ConnectGitHub() { const { isAuthorized, authorize, isLoading } = useIntegrateAuth(client, "github"); return ( ); } ``` Disconnect multi-account tokens with `disconnectAccount(provider, email, { userId })` on the server. Internal service auth [#internal-service-auth] Background jobs that call MCP tools without a user session should pass explicit context: ```typescript await serverClient.callTool("gmail_list_messages", { maxResults: 5 }, { context: { userId: actorUserId }, }); ``` Protect internal routes with shared secrets validated in `getSessionContext`. Related guides [#related-guides] * [Native Automations](/docs/guides/native-automations): hybrid scheduling * [Code Mode](/docs/artificial-intelligence/code-mode) * [Triggers](/docs/getting-started/triggers) # Options createMCPClient [#createmcpclient] Creates a new MCP client instance. ```typescript function createMCPClient(config: MCPClientConfig): MCPClient; ``` Parameters [#parameters] Returns [#returns] An `MCPClient` instance. Example [#example] ```typescript const client = createMCPClient({ integrations: [ githubIntegration({ clientId: process.env.GITHUB_CLIENT_ID!, clientSecret: process.env.GITHUB_CLIENT_SECRET!, }), ], timeout: 60000, headers: { "User-Agent": "my-app/1.0.0", }, clientInfo: { name: "my-app", version: "1.0.0", }, }); ``` MCPClient [#mcpclient] The main client class for interacting with the MCP server. connect() [#connect] Establishes connection to the MCP server. ```typescript async connect(): Promise ``` **Example:** ```typescript await client.connect(); ``` disconnect() [#disconnect] Closes the connection to the MCP server. ```typescript async disconnect(): Promise ``` **Example:** ```typescript await client.disconnect(); ``` Typed Integration Methods [#typed-integration-methods] Built-in integrations (GitHub, Gmail) provide fully typed methods for calling tools. **GitHub Integration Methods:** ```typescript client.github.createIssue(params); client.github.listIssues(params); client.github.getRepo(params); client.github.createPullRequest(params); // ... and more ``` **Gmail Integration Methods:** ```typescript client.gmail.sendEmail(params); client.gmail.listEmails(params); client.gmail.searchEmails(params); client.gmail.createLabel(params); // ... and more ``` **Server Methods:** ```typescript client.server.listToolsByIntegration(params); client.server.listAllProviders(); client.server.listConfiguredIntegrations(); // ... other server-level tools ``` **Example:** ```typescript // Fully typed with IntelliSense support const result = await client.github.createIssue({ owner: "owner", repo: "repo", title: "Bug report", body: "Description", }); ``` _callToolByName() [#_calltoolbyname] For integrations configured with `genericOAuthIntegration` or `createSimpleIntegration`, use this internal method to call tools directly. ```typescript async _callToolByName(name: string, args?: Record): Promise ``` **Parameters:** * `name` - Full tool name (e.g., 'slack\_send\_message') * `args` - Tool arguments as key-value pairs (optional) **Returns:** * `MCPToolCallResponse` - Tool execution result **Example:** ```typescript const result = await client._callToolByName("slack_send_message", { channel: "#general", text: "Hello!", }); ``` getTool() [#gettool] Gets a specific tool definition. ```typescript getTool(name: string): MCPTool | undefined ``` **Parameters:** * `name` - Tool name **Returns:** * `MCPTool` or `undefined` if not found **Example:** ```typescript const tool = client.getTool("github_create_issue"); console.log(tool?.inputSchema); ``` getEnabledTools() [#getenabledtools] Gets all enabled tools (filtered by integrations). ```typescript getEnabledTools(): MCPTool[] ``` **Returns:** * Array of `MCPTool` objects **Example:** ```typescript const tools = client.getEnabledTools(); console.log( "Enabled tools:", tools.map((t) => t.name) ); ``` getAvailableTools() [#getavailabletools] Gets all available tools from the server (unfiltered). ```typescript getAvailableTools(): MCPTool[] ``` **Returns:** * Array of `MCPTool` objects **Example:** ```typescript const tools = client.getAvailableTools(); console.log( "All tools:", tools.map((t) => t.name) ); ``` getOAuthConfig() [#getoauthconfig] Gets OAuth configuration for a specific integration. ```typescript getOAuthConfig(integrationId: string): OAuthConfig | undefined ``` **Parameters:** * `integrationId` - Integration identifier **Returns:** * `OAuthConfig` or `undefined` if not found **Example:** ```typescript const config = client.getOAuthConfig("github"); console.log("Scopes:", config?.scopes); ``` getAllOAuthConfigs() [#getalloauthconfigs] Gets all OAuth configurations. ```typescript getAllOAuthConfigs(): Map ``` **Returns:** * Map of integration IDs to OAuth configurations **Example:** ```typescript const configs = client.getAllOAuthConfigs(); for (const [integrationId, config] of configs) { console.log(`${integrationId}: ${config.provider}`); } ``` onMessage() [#onmessage] Registers a message handler. ```typescript onMessage(handler: (message: any) => void): () => void ``` **Parameters:** * `handler` - Function to handle messages **Returns:** * Unsubscribe function **Example:** ```typescript const unsubscribe = client.onMessage((message) => { console.log("Message:", message); }); // Later... unsubscribe(); ``` isConnected() [#isconnected] Checks if the client is connected. ```typescript isConnected(): boolean ``` **Returns:** * `true` if connected, `false` otherwise **Example:** ```typescript if (client.isConnected()) { console.log("Client is connected"); } ``` isInitialized() [#isinitialized] Checks if the client is initialized. ```typescript isInitialized(): boolean ``` **Returns:** * `true` if initialized, `false` otherwise **Example:** ```typescript if (client.isInitialized()) { console.log("Client is initialized"); } ``` getAuthState() [#getauthstate] Gets authentication state for a specific provider. ```typescript getAuthState(provider: string): { authenticated: boolean; lastError?: AuthenticationError } | undefined ``` **Parameters:** * `provider` - Provider identifier (e.g., 'github', 'gmail') **Returns:** * Authentication state object or `undefined` if provider not found **Example:** ```typescript const authState = client.getAuthState("github"); if (authState) { console.log("Authenticated:", authState.authenticated); if (authState.lastError) { console.log("Last error:", authState.lastError.message); } } ``` isProviderAuthenticated() [#isproviderauthenticated] Checks if a specific provider is authenticated. ```typescript isProviderAuthenticated(provider: string): boolean ``` **Parameters:** * `provider` - Provider identifier **Returns:** * `true` if authenticated, `false` otherwise **Example:** ```typescript if (client.isProviderAuthenticated("github")) { console.log("GitHub is authenticated"); } ``` reauthenticate() [#reauthenticate] Manually triggers re-authentication for a provider. ```typescript async reauthenticate(provider: string): Promise ``` **Parameters:** * `provider` - Provider identifier **Returns:** * `true` if re-authentication succeeded, `false` otherwise **Throws:** * Error if provider not found or no re-auth handler configured **Example:** ```typescript try { const success = await client.reauthenticate("github"); if (success) { console.log("Re-authentication successful"); } } catch (error) { console.error("Re-authentication failed:", error); } ``` Server Namespace Methods [#server-namespace-methods] The `server` namespace provides access to server-level tools and utilities that don't belong to a specific integration. client.server.listAllProviders() [#clientserverlistallproviders] List all providers available on the MCP server. ```typescript async listAllProviders(): Promise ``` **Returns:** * `MCPToolCallResponse` - Response containing all available providers **Example:** ```typescript const result = await client.server.listAllProviders(); console.log("All providers:", result); ``` client.server.listToolsByIntegration() [#clientserverlisttoolsbyintegration] List all tools available for a specific integration. ```typescript async listToolsByIntegration(params: { integration: string; }): Promise ``` **Parameters:** * `params.integration` (string) - The integration identifier (e.g., "github", "gmail") **Returns:** * `MCPToolCallResponse` - Response containing tools for the specified integration **Example:** ```typescript // List all GitHub tools const result = await client.server.listToolsByIntegration({ integration: "github", }); console.log("GitHub tools:", result); ``` client.server.listConfiguredIntegrations() [#clientserverlistconfiguredintegrations] List integrations configured for your application. The behavior depends on how you created your client: * **Default client** (`import { client } from 'integrate-sdk'`): Fetches from server to get integrations configured via `createMCPServer()` * **Custom client** (`createMCPClient({ integrations: [...] })`): Returns local config (no server call) * **Server client** (`createMCPServer`): Returns local config (they ARE the server) ```typescript async listConfiguredIntegrations(options?: { includeToolMetadata?: boolean; }): Promise<{ integrations: ConfiguredIntegration[]; }> ``` **Parameters:** * `options` (optional) - Configuration options * `includeToolMetadata` (boolean, default: false) - If true, fetches full tool metadata from the server for all configured integrations. Uses batched requests with concurrency control to avoid rate limiting. **Returns:** * Object with `integrations` array containing: * `id` (string) - Integration identifier * `name` (string) - Integration display name * `logoUrl` (string | undefined) - URL to the integration's logo image * `tools` (readonly string\[]) - Array of tool names available for this integration * `hasOAuth` (boolean) - Whether the integration requires OAuth * `scopes` (readonly string\[] | undefined) - OAuth scopes if applicable * `provider` (string | undefined) - OAuth provider name if applicable * `description` (string | undefined) - Short library blurb from the integration or the SDK catalog * `category` (string | undefined) - Library grouping label (e.g. Productivity, Business) from the integration or the SDK catalog * `toolMetadata` (ToolMetadata\[] | undefined) - Full tool metadata when `includeToolMetadata: true` is passed **Example (default client - fetches from server):** ```typescript import { client } from "integrate-sdk"; // Fetches from server to get what's actually configured const { integrations } = await client.server.listConfiguredIntegrations(); console.log(`Server has ${integrations.length} integrations:`); integrations.forEach((integration) => { console.log(`- ${integration.name} (${integration.id})`); }); ``` **Example (custom client - local config):** ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [githubIntegration()], }); // Returns local config - no server call const { integrations } = await customClient.server.listConfiguredIntegrations(); // Returns [{ id: 'github', ... }] ``` **Example (with metadata - includes server calls):** ```typescript // Get configured integrations with full tool metadata const { integrations } = await client.server.listConfiguredIntegrations({ includeToolMetadata: true, }); integrations.forEach((integration) => { console.log(`${integration.name}:`); integration.toolMetadata?.forEach((tool) => { console.log(` - ${tool.name}`); console.log(` ${tool.description}`); if (tool.inputSchema) { console.log(` Required: ${tool.inputSchema.required?.join(', ') || 'none'}`); } }); }); ``` **Note:** * The default client fetches from the server because it has all integrations pre-configured but only some may be configured on the server with OAuth credentials. * Custom clients return local config because the developer explicitly chose which integrations to use. * With `includeToolMetadata: true`, it fetches tool metadata for all integrations using batched requests with concurrency control (3 parallel requests at a time) to avoid rate limiting. * If metadata fetching fails for an integration, it returns an empty array for that integration's `toolMetadata` rather than failing the entire operation. Type Definitions [#type-definitions] MCPTool [#mcptool] MCPToolCallResponse [#mcptoolcallresponse] MCPToolCallParams [#mcptoolcallparams] OAuthConfig [#oauthconfig] MCPIntegration [#mcpintegration] ConfiguredIntegration [#configuredintegration] ReauthContext [#reauthcontext] OAuth Types [#oauth-types] PopupOptions [#popupoptions] OAuthFlowConfig [#oauthflowconfig] AuthStatus [#authstatus] ProviderTokenData [#providertokendata] OAuthCallbackParams [#oauthcallbackparams] OAuth Event Types [#oauth-event-types] AuthStartedEvent [#authstartedevent] AuthCompleteEvent [#authcompleteevent] AuthErrorEvent [#autherrorevent] AuthLogoutEvent [#authlogoutevent] AuthDisconnectEvent [#authdisconnectevent] Built-in Integrations [#built-in-integrations] githubIntegration() [#githubintegration] Creates a GitHub integration. ```typescript function githubIntegration(config: GitHubIntegrationConfig): MCPIntegration; ``` gmailIntegration() [#gmailintegration] Creates a Gmail integration. ```typescript function gmailIntegration(config: GmailIntegrationConfig): MCPIntegration; ``` genericOAuthIntegration() [#genericoauthintegration] Creates a generic OAuth integration. ```typescript function genericOAuthIntegration( config: GenericOAuthIntegrationConfig ): MCPIntegration; ``` createSimpleIntegration() [#createsimpleintegration] Creates a simple integration without OAuth. ```typescript function createSimpleIntegration(config: { id: string; tools: string[]; onInit?: (client: any) => Promise | void; onAfterConnect?: (client: any) => Promise | void; onDisconnect?: (client: any) => Promise | void; }): MCPIntegration; ``` **Parameters:** * `id` - Integration identifier * `tools` - Array of tool names to enable * `onInit` - Optional initialization hook * `onAfterConnect` - Optional post-connection hook * `onDisconnect` - Optional disconnect hook Vercel AI SDK Integration [#vercel-ai-sdk-integration] VercelAITool [#vercelaitool] Tool definition compatible with Vercel AI SDK v5: VercelAIToolsOptions [#vercelaitoolsoptions] Options for converting MCP tools to Vercel AI SDK format: getVercelAITools() [#getvercelaitools] Converts all enabled MCP tools to Vercel AI SDK format. ```typescript function getVercelAITools( client: MCPClient, options?: VercelAIToolsOptions ): Record; ``` **Parameters:** * `client` - Connected MCP client * `options` - Optional configuration (see VercelAIToolsOptions above) **Returns:** * Object mapping tool names to Vercel AI SDK tools **Example:** ```typescript // Client-side const tools = await getVercelAITools(mcpClient); // Server-side with provider tokens const tools = await getVercelAITools(serverClient, { providerTokens: { github: "ghp_...", gmail: "ya29..." }, }); const result = await generateText({ model: openai("gpt-4"), prompt: "Create a GitHub issue", tools, }); ``` convertMCPToolsToVercelAI() [#convertmcptoolstovercelai] Alternative name for `getVercelAITools()`. ```typescript function convertMCPToolsToVercelAI(client: MCPClient): Record; ``` convertMCPToolToVercelAI() [#convertmcptooltovercelai] Converts a single MCP tool to Vercel AI SDK format. ```typescript function convertMCPToolToVercelAI(tool: MCPTool, client: MCPClient): CoreTool; ``` **Parameters:** * `tool` - MCP tool definition * `client` - MCP client for execution **Returns:** * Tool in Vercel AI SDK format **Example:** ```typescript const tool = client.getTool("github_create_issue"); if (tool) { const vercelTool = convertMCPToolToVercelAI(tool, client); } ``` Constants [#constants] Server URL [#server-url] ```typescript const MCP_SERVER_URL = "https://mcp.integrate.dev/api/v1/mcp"; ``` Default Timeout [#default-timeout] ```typescript const DEFAULT_TIMEOUT = 30000; // 30 seconds ``` Error Types [#error-types] The SDK provides specific error classes for different failure scenarios. IntegrateSDKError [#integratesdkerror] Base error class for all SDK errors. ```typescript class IntegrateSDKError extends Error { name: "IntegrateSDKError"; } ``` AuthenticationError [#authenticationerror] Error thrown when authentication fails or tokens are invalid. ```typescript class AuthenticationError extends IntegrateSDKError { name: "AuthenticationError"; statusCode?: number; // HTTP status code (usually 401) provider?: string; // OAuth provider name } ``` **Example:** ```typescript import { isAuthError, AuthenticationError } from "integrate-sdk"; try { await client.github.createIssue({ owner: "user", repo: "repo", title: "Bug", }); } catch (error) { if (isAuthError(error)) { console.error(`Auth failed for ${error.provider}: ${error.message}`); } } ``` TokenExpiredError [#tokenexpirederror] Error thrown when OAuth tokens have expired. ```typescript class TokenExpiredError extends AuthenticationError { name: "TokenExpiredError"; provider?: string; // OAuth provider name } ``` **Example:** ```typescript import { isTokenExpiredError } from "integrate-sdk"; try { await client.github.createIssue({ owner: "user", repo: "repo", title: "Bug", }); } catch (error) { if (isTokenExpiredError(error)) { console.error(`Token expired for ${error.provider}`); // Trigger re-authentication } } ``` AuthorizationError [#authorizationerror] Error thrown when access is forbidden due to insufficient permissions. ```typescript class AuthorizationError extends IntegrateSDKError { name: "AuthorizationError"; statusCode?: number; // HTTP status code (usually 403) requiredScopes?: string[]; // Missing OAuth scopes } ``` **Example:** ```typescript import { isAuthorizationError } from "integrate-sdk"; try { await client.github.createIssue({ owner: "user", repo: "repo", title: "Bug", }); } catch (error) { if (isAuthorizationError(error)) { console.error("Insufficient permissions"); if (error.requiredScopes) { console.error("Required scopes:", error.requiredScopes); } } } ``` ConnectionError [#connectionerror] Error thrown when a connection to the server fails. ```typescript class ConnectionError extends IntegrateSDKError { name: "ConnectionError"; statusCode?: number; // HTTP status code } ``` ToolCallError [#toolcallerror] Error thrown when a tool call fails. ```typescript class ToolCallError extends IntegrateSDKError { name: "ToolCallError"; toolName: string; // Name of the tool that failed originalError?: unknown; // Original error from server } ``` Error Helper Functions [#error-helper-functions] Type guard functions for error handling: ```typescript // Check if error is any authentication error function isAuthError(error: unknown): error is AuthenticationError; // Check if error is specifically a token expired error function isTokenExpiredError(error: unknown): error is TokenExpiredError; // Check if error is an authorization error function isAuthorizationError(error: unknown): error is AuthorizationError; ``` **Example:** ```typescript import { isAuthError, isTokenExpiredError, isAuthorizationError, } from "integrate-sdk"; try { await client.github.createIssue({ owner: "user", repo: "repo", title: "Bug", }); } catch (error) { if (isTokenExpiredError(error)) { // Handle token expiration } else if (isAuthError(error)) { // Handle other auth errors } else if (isAuthorizationError(error)) { // Handle permission errors } else { // Handle other errors } } ``` parseServerError() [#parseservererror] Utility function to parse server errors into appropriate error types. ```typescript function parseServerError( error: any, context?: { toolName?: string; provider?: string } ): IntegrateSDKError; ``` This function is used internally by the SDK but can be useful for custom error handling. Triggers [#triggers] The Trigger API allows you to schedule tool executions for one-time or recurring jobs. client.trigger.create() [#clienttriggercreate] Create a new scheduled trigger. ```typescript async create(params: CreateTriggerParams): Promise ``` **Parameters:** **Returns:** The created trigger with generated ID and metadata. **Example:** ```typescript // One-time trigger const trigger = await client.trigger.create({ name: "Send Email", toolName: "gmail_send_email", toolArguments: { to: "user@example.com", subject: "Hello" }, schedule: { type: "once", runAt: new Date("2024-12-13T22:00:00Z") }, }); // Recurring trigger const daily = await client.trigger.create({ name: "Daily Report", toolName: "slack_send_message", toolArguments: { channel: "#team", text: "Daily report" }, schedule: { type: "cron", expression: "0 9 * * *" }, }); ``` client.trigger.list() [#clienttriggerlist] List triggers with optional filters. ```typescript async list(params?: ListTriggersParams): Promise ``` **Parameters:** **Returns:** **Example:** ```typescript // Get all triggers const { triggers, total } = await client.trigger.list(); // Get active triggers const active = await client.trigger.list({ status: "active", limit: 10 }); // Filter by tool name const emailTriggers = await client.trigger.list({ toolName: "gmail_send_email", }); ``` client.trigger.get() [#clienttriggerget] Get a specific trigger by ID. ```typescript async get(triggerId: string): Promise ``` **Parameters:** * `triggerId` (string) - The trigger ID to retrieve **Returns:** The trigger details. **Example:** ```typescript const trigger = await client.trigger.get("trig_abc123"); console.log(trigger.status); // 'active' console.log(trigger.nextRunAt); // '2024-12-13T22:00:00Z' ``` client.trigger.update() [#clienttriggerupdate] Update an existing trigger. ```typescript async update(triggerId: string, params: UpdateTriggerParams): Promise ``` **Parameters:** * `triggerId` (string) - The trigger ID to update * `params` (UpdateTriggerParams) - Partial trigger updates **Returns:** The updated trigger. **Example:** ```typescript // Update schedule await client.trigger.update("trig_abc123", { schedule: { type: "cron", expression: "0 10 * * *" }, }); // Update arguments await client.trigger.update("trig_abc123", { toolArguments: { channel: "#general" }, }); ``` client.trigger.delete() [#clienttriggerdelete] Delete a trigger permanently. ```typescript async delete(triggerId: string): Promise ``` **Parameters:** * `triggerId` (string) - The trigger ID to delete **Example:** ```typescript await client.trigger.delete("trig_abc123"); ``` client.trigger.pause() [#clienttriggerpause] Pause a trigger (stop future executions without deleting). ```typescript async pause(triggerId: string): Promise ``` **Parameters:** * `triggerId` (string) - The trigger ID to pause **Returns:** The updated trigger with status `'paused'`. **Example:** ```typescript const paused = await client.trigger.pause("trig_abc123"); console.log(paused.status); // 'paused' ``` client.trigger.resume() [#clienttriggerresume] Resume a paused trigger. ```typescript async resume(triggerId: string): Promise ``` **Parameters:** * `triggerId` (string) - The trigger ID to resume **Returns:** The updated trigger with status `'active'`. **Example:** ```typescript const resumed = await client.trigger.resume("trig_abc123"); console.log(resumed.status); // 'active' ``` client.trigger.run() [#clienttriggerrun] Execute a trigger immediately, bypassing the schedule. ```typescript async run(triggerId: string): Promise ``` **Parameters:** * `triggerId` (string) - The trigger ID to execute **Returns:** **Example:** ```typescript const result = await client.trigger.run("trig_abc123"); if (result.success) { console.log("Success:", result.result); } else { console.error("Failed:", result.error); } ``` Trigger Type [#trigger-type] TriggerSchedule Type [#triggerschedule-type] ```typescript type TriggerSchedule = | { type: "once"; runAt: string | Date } | { type: "cron"; expression: string }; ``` **One-time schedule:** ```typescript { type: 'once', runAt: new Date('2024-12-13T22:00:00Z') } { type: 'once', runAt: '2024-12-13T22:00:00Z' } ``` **Recurring schedule (cron):** ```typescript { type: 'cron', expression: '0 9 * * *' } // Daily at 9 AM { type: 'cron', expression: '0 9 * * 1-5' } // Weekdays at 9 AM { type: 'cron', expression: '0 */2 * * *' } // Every 2 hours ``` TriggerCallbacks [#triggercallbacks] Database storage callbacks for server-side configuration: **Example:** ```typescript import { createMCPServer } from "integrate-sdk/server"; export const { client } = createMCPServer({ triggers: { create: async (trigger, context) => { return db.trigger.create({ data: trigger }); }, get: async (id, context) => { return db.trigger.findFirst({ where: { id } }); }, list: async (params, context) => { const triggers = await db.trigger.findMany({ where: { status: params.status }, take: params.limit, }); return { triggers, total: triggers.length, hasMore: false }; }, update: async (id, updates, context) => { return db.trigger.update({ where: { id }, data: updates }); }, delete: async (id, context) => { await db.trigger.delete({ where: { id } }); }, }, }); ``` Next Steps [#next-steps] * Explore [Advanced Usage](/docs/getting-started/advanced-usage) for patterns and techniques * See example code in the repository # Adobe Acrobat Sign Integration The Adobe Acrobat Sign integration provides access to manage Adobe Acrobat Sign get user, list agreements, get agreement, create agreement, list library documents through the Integrate MCP server. Installation [#installation] The Adobe Acrobat Sign integration is included with the SDK: ```typescript import { adobeAcrobatSignIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Adobe Acrobat Sign OAuth App [#1-create-an-adobe-acrobat-sign-oauth-app] 1. Create an OAuth application for Adobe Acrobat Sign 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Adobe Acrobat Sign integration to your server configuration. The integration automatically reads `ADOBE_ACROBAT_SIGN_CLIENT_ID` and `ADOBE_ACROBAT_SIGN_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, adobeAcrobatSignIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ adobeAcrobatSignIntegration({ scopes: ["user_read", "agreement_read", "agreement_write", "library_read", "library_write"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript adobeAcrobatSignIntegration({ clientId: process.env.CUSTOM_ADOBE_ACROBAT_SIGN_ID, clientSecret: process.env.CUSTOM_ADOBE_ACROBAT_SIGN_SECRET, scopes: ["user_read", "agreement_read", "agreement_write", "library_read", "library_write"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("adobe_acrobat_sign"); const result = await client.adobe_acrobat_sign.getUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, adobeAcrobatSignIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [adobeAcrobatSignIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `user_read` * `agreement_read` * `agreement_write` * `library_read` * `library_write` Tools [#tools] adobe_acrobat_sign_get_user [#adobe_acrobat_sign_get_user] Acrobat sign get user *No parameters.* adobe_acrobat_sign_list_agreements [#adobe_acrobat_sign_list_agreements] Acrobat sign list agreements adobe_acrobat_sign_get_agreement [#adobe_acrobat_sign_get_agreement] Acrobat sign get agreement adobe_acrobat_sign_create_agreement [#adobe_acrobat_sign_create_agreement] Acrobat sign create agreement adobe_acrobat_sign_list_library_documents [#adobe_acrobat_sign_list_library_documents] Acrobat sign list library documents adobe_acrobat_sign_get_signing_urls [#adobe_acrobat_sign_get_signing_urls] Acrobat sign get signing urls Notes [#notes] * Category: Legal * Authentication mode: OAuth # Airtable Integration The Airtable integration provides access to manage Airtable bases, tables, and records through the Integrate MCP server. Installation [#installation] The Airtable integration is included with the SDK: ```typescript import { airtableIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Airtable OAuth App [#1-create-an-airtable-oauth-app] 1. Go to [Airtable Developer Hub](https://airtable.com/create/oauth) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Airtable integration to your server configuration. The integration automatically reads `AIRTABLE_CLIENT_ID` and `AIRTABLE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, airtableIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ airtableIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript airtableIntegration({ clientId: process.env.CUSTOM_AIRTABLE_ID, clientSecret: process.env.CUSTOM_AIRTABLE_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("airtable"); const result = await client.airtable.listBases({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, airtableIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [airtableIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] airtable_list_bases [#airtable_list_bases] List all accessible bases airtable_get_base [#airtable_get_base] Get a specific base airtable_list_tables [#airtable_list_tables] List tables in a base airtable_get_table [#airtable_get_table] Get a specific table schema airtable_list_records [#airtable_list_records] List records in a table airtable_get_record [#airtable_get_record] Get a specific record airtable_create_record [#airtable_create_record] Create a new record airtable_update_record [#airtable_update_record] Update an existing record airtable_search_records [#airtable_search_records] Search for records using a formula airtable_delete_record [#airtable_delete_record] Delete a record airtable_create_base [#airtable_create_base] Create a new base airtable_create_table [#airtable_create_table] Create a new table in a base airtable_update_table [#airtable_update_table] Update a table's name or description airtable_create_field [#airtable_create_field] Create a new field in a table airtable_update_field [#airtable_update_field] Update a field's name or description airtable_list_comments [#airtable_list_comments] List comments on a record airtable_create_comment [#airtable_create_comment] Create a comment on a record airtable_update_comment [#airtable_update_comment] Update a comment airtable_delete_comment [#airtable_delete_comment] Delete a comment airtable_list_webhooks [#airtable_list_webhooks] List webhooks for a base airtable_create_webhook [#airtable_create_webhook] Create a webhook for a base airtable_delete_webhook [#airtable_delete_webhook] Delete a webhook airtable_list_webhook_payloads [#airtable_list_webhook_payloads] List webhook payloads airtable_refresh_webhook [#airtable_refresh_webhook] Refresh a webhook to extend its expiration Notes [#notes] * Category: Business * Authentication mode: OAuth # Alpaca Integration The Alpaca integration provides access to trade US equities and crypto with Alpaca: account, orders, positions, clock, and assets through the Integrate MCP server. Installation [#installation] The Alpaca integration is included with the SDK: ```typescript import { alpacaIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Alpaca to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, alpacaIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ alpacaIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.alpaca.getAccount({}); console.log(result); ``` Environment Variables [#environment-variables] * `ALPACA_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] alpaca_get_account [#alpaca_get_account] Get account *No parameters.* alpaca_list_positions [#alpaca_list_positions] List positions *No parameters.* alpaca_get_position [#alpaca_get_position] Get position alpaca_list_orders [#alpaca_list_orders] List orders alpaca_get_order [#alpaca_get_order] Get order alpaca_create_order [#alpaca_create_order] Create order alpaca_cancel_order [#alpaca_cancel_order] Cancel order alpaca_cancel_all_orders [#alpaca_cancel_all_orders] Cancel all orders alpaca_get_clock [#alpaca_get_clock] Get clock *No parameters.* alpaca_get_calendar [#alpaca_get_calendar] Get calendar alpaca_list_assets [#alpaca_list_assets] List assets alpaca_get_asset [#alpaca_get_asset] Get asset alpaca_get_portfolio_history [#alpaca_get_portfolio_history] Get portfolio history Notes [#notes] * Category: Finance * Authentication mode: API key # Amadeus Integration The Amadeus integration provides access to manage Amadeus search flights, price flight, search hotels, get hotel offers, search locations through the Integrate MCP server. Installation [#installation] The Amadeus integration is included with the SDK: ```typescript import { amadeusIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Amadeus OAuth App [#1-create-an-amadeus-oauth-app] 1. Create an OAuth application for Amadeus 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Amadeus integration to your server configuration. The integration automatically reads `AMADEUS_CLIENT_ID` and `AMADEUS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, amadeusIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ amadeusIntegration({ scopes: ["travel"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript amadeusIntegration({ clientId: process.env.CUSTOM_AMADEUS_ID, clientSecret: process.env.CUSTOM_AMADEUS_SECRET, scopes: ["travel"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("amadeus"); const result = await client.amadeus.searchFlights({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, amadeusIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [amadeusIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `travel` Tools [#tools] amadeus_search_flights [#amadeus_search_flights] Search flights amadeus_price_flight [#amadeus_price_flight] Price flight amadeus_search_hotels [#amadeus_search_hotels] Search hotels amadeus_get_hotel_offers [#amadeus_get_hotel_offers] Get hotel offers amadeus_search_locations [#amadeus_search_locations] Search locations Notes [#notes] * Category: Travel * Authentication mode: OAuth # Amazon Selling Partner Integration The Amazon Selling Partner integration provides access to manage Amazon Selling Partner search catalog items, list orders, get order, list inventory, list listings through the Integrate MCP server. Installation [#installation] The Amazon Selling Partner integration is included with the SDK: ```typescript import { amazonIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Amazon Selling Partner OAuth App [#1-create-an-amazon-selling-partner-oauth-app] 1. Create an OAuth application for Amazon Selling Partner 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Amazon Selling Partner integration to your server configuration. The integration automatically reads `AMAZON_CLIENT_ID` and `AMAZON_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, amazonIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ amazonIntegration({ scopes: ["sellingpartnerapi::notifications", "sellingpartnerapi::migration"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript amazonIntegration({ clientId: process.env.CUSTOM_AMAZON_ID, clientSecret: process.env.CUSTOM_AMAZON_SECRET, scopes: ["sellingpartnerapi::notifications", "sellingpartnerapi::migration"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("amazon"); const result = await client.amazon.searchCatalogItems({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, amazonIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [amazonIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `sellingpartnerapi::notifications` * `sellingpartnerapi::migration` Tools [#tools] amazon_search_catalog_items [#amazon_search_catalog_items] Search catalog items amazon_list_orders [#amazon_list_orders] List orders amazon_get_order [#amazon_get_order] Get order amazon_list_inventory [#amazon_list_inventory] List inventory amazon_list_listings [#amazon_list_listings] List listings amazon_patch_listing [#amazon_patch_listing] Patch listing Notes [#notes] * Category: Commerce * Authentication mode: OAuth # Amazon Ads Integration The Amazon Ads integration provides access to manage Amazon Ads list profiles, list campaigns, create campaigns, list ad groups, list keywords through the Integrate MCP server. Installation [#installation] The Amazon Ads integration is included with the SDK: ```typescript import { amazonAdsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Amazon Ads OAuth App [#1-create-an-amazon-ads-oauth-app] 1. Create an OAuth application for Amazon Ads 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Amazon Ads integration to your server configuration. The integration automatically reads `AMAZON_ADS_CLIENT_ID` and `AMAZON_ADS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, amazonAdsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ amazonAdsIntegration({ scopes: ["advertising::campaign_management"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript amazonAdsIntegration({ clientId: process.env.CUSTOM_AMAZON_ADS_ID, clientSecret: process.env.CUSTOM_AMAZON_ADS_SECRET, scopes: ["advertising::campaign_management"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("amazon_ads"); const result = await client.amazon_ads.listProfiles({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, amazonAdsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [amazonAdsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `advertising::campaign_management` Tools [#tools] amazon_ads_list_profiles [#amazon_ads_list_profiles] Ads list profiles *No parameters.* amazon_ads_list_campaigns [#amazon_ads_list_campaigns] Ads list campaigns amazon_ads_create_campaigns [#amazon_ads_create_campaigns] Ads create campaigns amazon_ads_list_ad_groups [#amazon_ads_list_ad_groups] Ads list ad groups amazon_ads_list_keywords [#amazon_ads_list_keywords] Ads list keywords amazon_ads_request_report [#amazon_ads_request_report] Ads request report Notes [#notes] * Category: Marketing * Authentication mode: OAuth # Asana Integration The Asana integration provides access to manage Asana workspaces, projects, sections, tasks, stories, users, and teams through the Integrate MCP server. Installation [#installation] The Asana integration is included with the SDK: ```typescript import { asanaIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Asana OAuth App [#1-create-an-asana-oauth-app] 1. Create an OAuth application for Asana 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Asana integration to your server configuration. The integration automatically reads `ASANA_CLIENT_ID` and `ASANA_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, asanaIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ asanaIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript asanaIntegration({ clientId: process.env.CUSTOM_ASANA_ID, clientSecret: process.env.CUSTOM_ASANA_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("asana"); const result = await client.asana.getCurrentUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, asanaIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [asanaIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] asana_get_current_user [#asana_get_current_user] Get current user *No parameters.* asana_list_workspaces [#asana_list_workspaces] List workspaces asana_list_projects [#asana_list_projects] List projects asana_get_project [#asana_get_project] Get project asana_create_project [#asana_create_project] Create project asana_update_project [#asana_update_project] Update project asana_list_sections [#asana_list_sections] List sections asana_list_tasks [#asana_list_tasks] List tasks asana_get_task [#asana_get_task] Get task asana_create_task [#asana_create_task] Create task asana_update_task [#asana_update_task] Update task asana_delete_task [#asana_delete_task] Delete task asana_list_stories [#asana_list_stories] List stories asana_create_story [#asana_create_story] Create story asana_list_users [#asana_list_users] List users asana_list_teams [#asana_list_teams] List teams Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Astronomer Integration The Astronomer integration provides access to manage Astro organizations, workspaces, deployments, clusters, and deploy history via the Astro API v1 through the Integrate MCP server. Installation [#installation] The Astronomer integration is included with the SDK: ```typescript import { astronomerIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Astronomer to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, astronomerIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ astronomerIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.astronomer.getSelf({}); console.log(result); ``` Environment Variables [#environment-variables] * `ASTRONOMER_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] astronomer_get_self [#astronomer_get_self] Get self astronomer_list_organizations [#astronomer_list_organizations] List organizations astronomer_get_organization [#astronomer_get_organization] Get organization astronomer_list_workspaces [#astronomer_list_workspaces] List workspaces astronomer_get_workspace [#astronomer_get_workspace] Get workspace astronomer_list_clusters [#astronomer_list_clusters] List clusters astronomer_get_cluster [#astronomer_get_cluster] Get cluster astronomer_list_deployments [#astronomer_list_deployments] List deployments astronomer_get_deployment [#astronomer_get_deployment] Get deployment astronomer_create_deployment [#astronomer_create_deployment] Create deployment astronomer_update_deployment [#astronomer_update_deployment] Update deployment astronomer_list_deploys [#astronomer_list_deploys] List deploys astronomer_get_deploy [#astronomer_get_deploy] Get deploy Notes [#notes] * Category: Engineering * Authentication mode: API key # Attio Integration The Attio integration provides access to manage Attio people, companies, records, and tasks through the Integrate MCP server. Installation [#installation] The Attio integration is included with the SDK: ```typescript import { attioIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Attio OAuth App [#1-create-an-attio-oauth-app] 1. Go to [App Developer Portal](https://app.attio.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Attio integration to your server configuration. The integration automatically reads `ATTIO_CLIENT_ID` and `ATTIO_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, attioIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ attioIntegration({ scopes: ["record_permission:read-write", "object_configuration:read", "user_management:read", "task:read"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript attioIntegration({ clientId: process.env.CUSTOM_ATTIO_ID, clientSecret: process.env.CUSTOM_ATTIO_SECRET, scopes: ["record_permission:read-write", "object_configuration:read", "user_management:read", "task:read"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("attio"); const result = await client.attio.getSelf({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, attioIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [attioIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `record_permission:read-write` * `object_configuration:read` * `user_management:read` * `task:read` Tools [#tools] attio_get_self [#attio_get_self] Get self *No parameters.* attio_query_people [#attio_query_people] Query people attio_get_person [#attio_get_person] Get person attio_create_person [#attio_create_person] Create person attio_update_person [#attio_update_person] Update person attio_assert_person [#attio_assert_person] Assert person attio_query_companies [#attio_query_companies] Query companies attio_get_company [#attio_get_company] Get company attio_create_company [#attio_create_company] Create company attio_update_company [#attio_update_company] Update company attio_assert_company [#attio_assert_company] Assert company attio_list_tasks [#attio_list_tasks] List tasks attio_get_task [#attio_get_task] Get task Notes [#notes] * Category: Business * Authentication mode: OAuth # Auth0 Integration The Auth0 integration provides access to manage Auth0 users, applications, and tenant configuration through the Integrate MCP server. Installation [#installation] The Auth0 integration is included with the SDK: ```typescript import { auth0Integration } from "integrate-sdk/server"; ``` Setup [#setup] Add Auth0 to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, auth0Integration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ auth0Integration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.auth0.listUsers({}); console.log(result); ``` Environment Variables [#environment-variables] * `AUTH0_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] auth0_list_users [#auth0_list_users] List users auth0_get_user [#auth0_get_user] Get user auth0_create_user [#auth0_create_user] Create user auth0_patch_user [#auth0_patch_user] Patch user auth0_delete_user [#auth0_delete_user] Delete user auth0_list_connections [#auth0_list_connections] List connections auth0_get_connection [#auth0_get_connection] Get connection auth0_list_clients [#auth0_list_clients] List clients auth0_get_client [#auth0_get_client] Get client auth0_create_client [#auth0_create_client] Create client auth0_patch_client [#auth0_patch_client] Patch client Notes [#notes] * Category: Identity & Access * Authentication mode: API key # Amazon Web Services Integration The Amazon Web Services integration provides access to query AWS accounts and resources using SigV4 (control-plane read APIs: STS, EC2, S3, Lambda, CloudFormation, IAM). through the Integrate MCP server. Installation [#installation] The Amazon Web Services integration is included with the SDK: ```typescript import { awsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Amazon Web Services to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, awsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ awsIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.aws.stsGetCallerIdentity({}); console.log(result); ``` Environment Variables [#environment-variables] * `AWS_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] aws_sts_get_caller_identity [#aws_sts_get_caller_identity] Sts get caller identity *No parameters.* aws_ec2_describe_regions [#aws_ec2_describe_regions] Ec2 describe regions aws_ec2_describe_instances [#aws_ec2_describe_instances] Ec2 describe instances aws_s3_list_buckets [#aws_s3_list_buckets] S3 list buckets *No parameters.* aws_lambda_list_functions [#aws_lambda_list_functions] Lambda list functions aws_cloudformation_list_stacks [#aws_cloudformation_list_stacks] Cloudformation list stacks aws_iam_list_account_aliases [#aws_iam_list_account_aliases] Iam list account aliases *No parameters.* Notes [#notes] * Category: Infrastructure * Authentication mode: API key # Azure DevOps Integration The Azure DevOps integration provides access to manage Azure DevOps projects, repositories, pull requests, builds, and work items through the Integrate MCP server. Installation [#installation] The Azure DevOps integration is included with the SDK: ```typescript import { azureDevopsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Azure DevOps OAuth App [#1-create-an-azure-devops-oauth-app] 1. Create an OAuth application for Azure DevOps 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Azure DevOps integration to your server configuration. The integration automatically reads `AZURE_DEVOPS_CLIENT_ID` and `AZURE_DEVOPS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, azureDevopsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ azureDevopsIntegration({ scopes: ["vso.profile", "vso.project", "vso.code_write", "vso.build", "vso.work_write"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript azureDevopsIntegration({ clientId: process.env.CUSTOM_AZURE_DEVOPS_ID, clientSecret: process.env.CUSTOM_AZURE_DEVOPS_SECRET, scopes: ["vso.profile", "vso.project", "vso.code_write", "vso.build", "vso.work_write"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("azure_devops"); const result = await client.azure_devops.listProjects({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, azureDevopsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [azureDevopsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `vso.profile` * `vso.project` * `vso.code_write` * `vso.build` * `vso.work_write` Tools [#tools] azure_devops_list_projects [#azure_devops_list_projects] Devops list projects azure_devops_list_repositories [#azure_devops_list_repositories] Devops list repositories azure_devops_list_pull_requests [#azure_devops_list_pull_requests] Devops list pull requests azure_devops_list_builds [#azure_devops_list_builds] Devops list builds azure_devops_queue_build [#azure_devops_queue_build] Devops queue build azure_devops_get_work_item [#azure_devops_get_work_item] Devops get work item Notes [#notes] * Category: Engineering * Authentication mode: OAuth # BambooHR Integration The BambooHR integration provides access to manage BambooHR get company report, list employees, get employee, update employee, list time off requests through the Integrate MCP server. Installation [#installation] The BambooHR integration is included with the SDK: ```typescript import { bamboohrIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a BambooHR OAuth App [#1-create-a-bamboohr-oauth-app] 1. Create an OAuth application for BambooHR 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the BambooHR integration to your server configuration. The integration automatically reads `BAMBOOHR_CLIENT_ID` and `BAMBOOHR_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, bamboohrIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ bamboohrIntegration({ scopes: ["employee.read", "employee.write", "time_off.read", "time_off.write"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript bamboohrIntegration({ clientId: process.env.CUSTOM_BAMBOOHR_ID, clientSecret: process.env.CUSTOM_BAMBOOHR_SECRET, scopes: ["employee.read", "employee.write", "time_off.read", "time_off.write"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("bamboohr"); const result = await client.bamboohr.getCompanyReport({ report_json: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, bamboohrIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [bamboohrIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `employee.read` * `employee.write` * `time_off.read` * `time_off.write` Tools [#tools] bamboohr_get_company_report [#bamboohr_get_company_report] Get company report bamboohr_list_employees [#bamboohr_list_employees] List employees bamboohr_get_employee [#bamboohr_get_employee] Get employee bamboohr_update_employee [#bamboohr_update_employee] Update employee bamboohr_list_time_off_requests [#bamboohr_list_time_off_requests] List time off requests bamboohr_create_time_off_request [#bamboohr_create_time_off_request] Create time off request Notes [#notes] * Category: HR & Recruiting * Authentication mode: OAuth # Better Stack Integration The Better Stack integration provides access to ingest and manage log sources, collectors, and metrics with Better Stack Logs (Logtail) Telemetry API through the Integrate MCP server. Installation [#installation] The Better Stack integration is included with the SDK: ```typescript import { betterstackIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Better Stack to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, betterstackIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ betterstackIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.betterstack.listSources({}); console.log(result); ``` Environment Variables [#environment-variables] * `BETTERSTACK_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] betterstack_list_sources [#betterstack_list_sources] List sources betterstack_get_source [#betterstack_get_source] Get source betterstack_create_source [#betterstack_create_source] Create source betterstack_update_source [#betterstack_update_source] Update source betterstack_delete_source [#betterstack_delete_source] Delete source betterstack_list_source_groups [#betterstack_list_source_groups] List source groups betterstack_get_source_group [#betterstack_get_source_group] Get source group betterstack_update_source_group [#betterstack_update_source_group] Update source group betterstack_list_collectors [#betterstack_list_collectors] List collectors betterstack_list_source_metrics [#betterstack_list_source_metrics] List source metrics betterstack_ingest_logs [#betterstack_ingest_logs] Ingest logs Notes [#notes] * Category: Engineering * Authentication mode: API key # BigCommerce Integration The BigCommerce integration provides access to manage BigCommerce list products, get product, create product, list orders, get order through the Integrate MCP server. Installation [#installation] The BigCommerce integration is included with the SDK: ```typescript import { bigcommerceIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a BigCommerce OAuth App [#1-create-a-bigcommerce-oauth-app] 1. Create an OAuth application for BigCommerce 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the BigCommerce integration to your server configuration. The integration automatically reads `BIGCOMMERCE_CLIENT_ID` and `BIGCOMMERCE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, bigcommerceIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ bigcommerceIntegration({ scopes: ["store_v2_products", "store_v2_orders", "store_v2_customers", "store_v2_information"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript bigcommerceIntegration({ clientId: process.env.CUSTOM_BIGCOMMERCE_ID, clientSecret: process.env.CUSTOM_BIGCOMMERCE_SECRET, scopes: ["store_v2_products", "store_v2_orders", "store_v2_customers", "store_v2_information"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("bigcommerce"); const result = await client.bigcommerce.listProducts({ store_hash: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, bigcommerceIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [bigcommerceIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `store_v2_products` * `store_v2_orders` * `store_v2_customers` * `store_v2_information` Tools [#tools] bigcommerce_list_products [#bigcommerce_list_products] List products bigcommerce_get_product [#bigcommerce_get_product] Get product bigcommerce_create_product [#bigcommerce_create_product] Create product bigcommerce_list_orders [#bigcommerce_list_orders] List orders bigcommerce_get_order [#bigcommerce_get_order] Get order bigcommerce_list_customers [#bigcommerce_list_customers] List customers Notes [#notes] * Category: Commerce * Authentication mode: OAuth # BigQuery Integration The BigQuery integration provides access to manage BigQuery list projects, list datasets, list tables, get table, query through the Integrate MCP server. Installation [#installation] The BigQuery integration is included with the SDK: ```typescript import { bigqueryIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a BigQuery OAuth App [#1-create-a-bigquery-oauth-app] 1. Create an OAuth application for BigQuery 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the BigQuery integration to your server configuration. The integration automatically reads `BIGQUERY_CLIENT_ID` and `BIGQUERY_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, bigqueryIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ bigqueryIntegration({ scopes: ["https://www.googleapis.com/auth/bigquery", "https://www.googleapis.com/auth/cloud-platform"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript bigqueryIntegration({ clientId: process.env.CUSTOM_BIGQUERY_ID, clientSecret: process.env.CUSTOM_BIGQUERY_SECRET, scopes: ["https://www.googleapis.com/auth/bigquery", "https://www.googleapis.com/auth/cloud-platform"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("bigquery"); const result = await client.bigquery.listProjects({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, bigqueryIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [bigqueryIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `https://www.googleapis.com/auth/bigquery` * `https://www.googleapis.com/auth/cloud-platform` Tools [#tools] bigquery_list_projects [#bigquery_list_projects] List projects bigquery_list_datasets [#bigquery_list_datasets] List datasets bigquery_list_tables [#bigquery_list_tables] List tables bigquery_get_table [#bigquery_get_table] Get table bigquery_query [#bigquery_query] Query bigquery_list_jobs [#bigquery_list_jobs] List jobs Notes [#notes] * Category: Data & BI * Authentication mode: OAuth # Binance Integration The Binance integration provides access to read Binance Spot market data and account information with API keys scoped to reading only through the Integrate MCP server. Installation [#installation] The Binance integration is included with the SDK: ```typescript import { binanceIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Binance to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, binanceIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ binanceIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.binance.ping({}); console.log(result); ``` Environment Variables [#environment-variables] * `BINANCE_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] binance_ping [#binance_ping] Ping *No parameters.* binance_get_server_time [#binance_get_server_time] Get server time *No parameters.* binance_get_exchange_info [#binance_get_exchange_info] Get exchange info binance_get_ticker_price [#binance_get_ticker_price] Get ticker price binance_get_ticker_24hr [#binance_get_ticker_24hr] Get ticker 24hr *No parameters.* binance_get_order_book [#binance_get_order_book] Get order book binance_get_recent_trades [#binance_get_recent_trades] Get recent trades binance_get_klines [#binance_get_klines] Get klines binance_get_account [#binance_get_account] Get account *No parameters.* binance_get_open_orders [#binance_get_open_orders] Get open orders binance_get_all_orders [#binance_get_all_orders] Get all orders binance_get_my_trades [#binance_get_my_trades] Get my trades Notes [#notes] * Category: Finance * Authentication mode: API key # Bitbucket Cloud Integration The Bitbucket Cloud integration provides access to manage Bitbucket Cloud workspaces, repositories, branches, commits, pull requests, issues, and pipelines through the Integrate MCP server. Installation [#installation] The Bitbucket Cloud integration is included with the SDK: ```typescript import { bitbucketIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Bitbucket Cloud OAuth App [#1-create-a-bitbucket-cloud-oauth-app] 1. Create an OAuth application for Bitbucket Cloud 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Bitbucket Cloud integration to your server configuration. The integration automatically reads `BITBUCKET_CLIENT_ID` and `BITBUCKET_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, bitbucketIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ bitbucketIntegration({ scopes: ["account", "repository", "pullrequest", "issue", "pipeline"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript bitbucketIntegration({ clientId: process.env.CUSTOM_BITBUCKET_ID, clientSecret: process.env.CUSTOM_BITBUCKET_SECRET, scopes: ["account", "repository", "pullrequest", "issue", "pipeline"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("bitbucket"); const result = await client.bitbucket.getCurrentUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, bitbucketIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [bitbucketIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `account` * `repository` * `pullrequest` * `issue` * `pipeline` Tools [#tools] bitbucket_get_current_user [#bitbucket_get_current_user] Get current user *No parameters.* bitbucket_list_workspaces [#bitbucket_list_workspaces] List workspaces bitbucket_list_repositories [#bitbucket_list_repositories] List repositories bitbucket_get_repository [#bitbucket_get_repository] Get repository bitbucket_list_branches [#bitbucket_list_branches] List branches bitbucket_list_commits [#bitbucket_list_commits] List commits bitbucket_get_commit [#bitbucket_get_commit] Get commit bitbucket_list_pull_requests [#bitbucket_list_pull_requests] List pull requests bitbucket_get_pull_request [#bitbucket_get_pull_request] Get pull request bitbucket_create_pull_request [#bitbucket_create_pull_request] Create pull request bitbucket_list_issues [#bitbucket_list_issues] List issues bitbucket_get_issue [#bitbucket_get_issue] Get issue bitbucket_create_issue [#bitbucket_create_issue] Create issue bitbucket_list_pipelines [#bitbucket_list_pipelines] List pipelines bitbucket_trigger_pipeline [#bitbucket_trigger_pipeline] Trigger pipeline Notes [#notes] * Category: Engineering * Authentication mode: OAuth # Box Integration The Box integration provides access to manage Box files, folders, sharing, comments, search, and collaborations through the Integrate MCP server. Installation [#installation] The Box integration is included with the SDK: ```typescript import { boxIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Box OAuth App [#1-create-a-box-oauth-app] 1. Create an OAuth application for Box 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Box integration to your server configuration. The integration automatically reads `BOX_CLIENT_ID` and `BOX_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, boxIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ boxIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript boxIntegration({ clientId: process.env.CUSTOM_BOX_ID, clientSecret: process.env.CUSTOM_BOX_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("box"); const result = await client.box.getCurrentUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, boxIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [boxIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] box_get_current_user [#box_get_current_user] Get current user *No parameters.* box_list_folder_items [#box_list_folder_items] List folder items box_get_file [#box_get_file] Get file box_get_folder [#box_get_folder] Get folder box_create_folder [#box_create_folder] Create folder box_update_file [#box_update_file] Update file box_update_folder [#box_update_folder] Update folder box_delete_file [#box_delete_file] Delete file box_delete_folder [#box_delete_folder] Delete folder box_upload_text_file [#box_upload_text_file] Upload text file box_download_file [#box_download_file] Download file box_search [#box_search] Search box_create_shared_link [#box_create_shared_link] Create shared link box_create_collaboration [#box_create_collaboration] Create collaboration box_list_comments [#box_list_comments] List comments box_create_comment [#box_create_comment] Create comment box_delete_comment [#box_delete_comment] Delete comment Notes [#notes] * Category: Storage * Authentication mode: OAuth # Cal.com Integration The Cal.com integration provides access to manage Cal.com bookings and schedules through the Integrate MCP server. Installation [#installation] The Cal.com integration is included with the SDK: ```typescript import { calcomIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Cal.com OAuth App [#1-create-a-calcom-oauth-app] 1. Go to [Cal.com Platform Settings](https://app.cal.com/settings/developer) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Cal.com integration to your server configuration. The integration automatically reads `CALCOM_CLIENT_ID` and `CALCOM_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, calcomIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ calcomIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript calcomIntegration({ clientId: process.env.CUSTOM_CALCOM_ID, clientSecret: process.env.CUSTOM_CALCOM_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("calcom"); const result = await client.calcom.listBookings({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, calcomIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [calcomIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] calcom_list_bookings [#calcom_list_bookings] List all bookings calcom_get_booking [#calcom_get_booking] Get booking details calcom_create_booking [#calcom_create_booking] Create a new booking calcom_cancel_booking [#calcom_cancel_booking] Cancel a booking calcom_reschedule_booking [#calcom_reschedule_booking] Reschedule a booking calcom_update_booking [#calcom_update_booking] Update an existing booking calcom_get_booking_recordings [#calcom_get_booking_recordings] Get recordings for a booking calcom_get_booking_transcripts [#calcom_get_booking_transcripts] Get transcripts for a booking calcom_list_event_types [#calcom_list_event_types] List event types calcom_get_event_type [#calcom_get_event_type] Get a specific event type calcom_create_event_type [#calcom_create_event_type] Create a new event type calcom_update_event_type [#calcom_update_event_type] Update an event type calcom_delete_event_type [#calcom_delete_event_type] Delete an event type calcom_list_team_event_types [#calcom_list_team_event_types] List event types for a team calcom_get_availability [#calcom_get_availability] Get availability slots calcom_get_availability_rule [#calcom_get_availability_rule] Get an availability rule calcom_create_availability_rule [#calcom_create_availability_rule] Create an availability rule calcom_update_availability_rule [#calcom_update_availability_rule] Update an availability rule calcom_delete_availability_rule [#calcom_delete_availability_rule] Delete an availability rule calcom_list_schedules [#calcom_list_schedules] List schedules calcom_get_schedule [#calcom_get_schedule] Get a specific schedule calcom_create_schedule [#calcom_create_schedule] Create a new schedule calcom_update_schedule [#calcom_update_schedule] Update a schedule calcom_delete_schedule [#calcom_delete_schedule] Delete a schedule calcom_get_slots [#calcom_get_slots] Get available time slots calcom_list_attendees [#calcom_list_attendees] List attendees *No parameters.* calcom_get_attendee [#calcom_get_attendee] Get a specific attendee calcom_create_attendee [#calcom_create_attendee] Create a new attendee calcom_update_attendee [#calcom_update_attendee] Update an attendee calcom_delete_attendee [#calcom_delete_attendee] Delete an attendee calcom_list_teams [#calcom_list_teams] List teams *No parameters.* calcom_get_team [#calcom_get_team] Get a specific team calcom_create_team [#calcom_create_team] Create a new team calcom_update_team [#calcom_update_team] Update a team calcom_delete_team [#calcom_delete_team] Delete a team calcom_list_memberships [#calcom_list_memberships] List memberships *No parameters.* calcom_get_membership [#calcom_get_membership] Get a specific membership calcom_create_membership [#calcom_create_membership] Create a membership calcom_update_membership [#calcom_update_membership] Update a membership calcom_delete_membership [#calcom_delete_membership] Delete a membership calcom_list_webhooks [#calcom_list_webhooks] List webhooks *No parameters.* calcom_get_webhook [#calcom_get_webhook] Get a specific webhook calcom_create_webhook [#calcom_create_webhook] Create a webhook calcom_update_webhook [#calcom_update_webhook] Update a webhook calcom_delete_webhook [#calcom_delete_webhook] Delete a webhook calcom_list_payments [#calcom_list_payments] List payments *No parameters.* calcom_get_payment [#calcom_get_payment] Get a specific payment calcom_list_users [#calcom_list_users] List users *No parameters.* calcom_get_user [#calcom_get_user] Get a specific user calcom_create_user [#calcom_create_user] Create a new user calcom_update_user [#calcom_update_user] Update a user calcom_delete_user [#calcom_delete_user] Delete a user calcom_get_me [#calcom_get_me] Get current user info *No parameters.* Notes [#notes] * Category: Scheduling * Authentication mode: OAuth # Calendly Integration The Calendly integration provides access to manage Calendly user profiles, event types, scheduled events, invitees, and availability schedules through the Integrate MCP server. Installation [#installation] The Calendly integration is included with the SDK: ```typescript import { calendlyIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Calendly OAuth App [#1-create-a-calendly-oauth-app] 1. Create an OAuth application for Calendly 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Calendly integration to your server configuration. The integration automatically reads `CALENDLY_CLIENT_ID` and `CALENDLY_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, calendlyIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ calendlyIntegration({ scopes: ["user:read", "event_types:read", "scheduled_events:read", "organization_memberships:read", "routing:read"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript calendlyIntegration({ clientId: process.env.CUSTOM_CALENDLY_ID, clientSecret: process.env.CUSTOM_CALENDLY_SECRET, scopes: ["user:read", "event_types:read", "scheduled_events:read", "organization_memberships:read", "routing:read"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("calendly"); const result = await client.calendly.getCurrentUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, calendlyIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [calendlyIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `user:read` * `event_types:read` * `scheduled_events:read` * `organization_memberships:read` * `routing:read` Tools [#tools] calendly_get_current_user [#calendly_get_current_user] Get current user *No parameters.* calendly_list_event_types [#calendly_list_event_types] List event types calendly_get_event_type [#calendly_get_event_type] Get event type calendly_list_scheduled_events [#calendly_list_scheduled_events] List scheduled events calendly_get_scheduled_event [#calendly_get_scheduled_event] Get scheduled event calendly_list_scheduled_event_invitees [#calendly_list_scheduled_event_invitees] List scheduled event invitees calendly_list_availability_schedules [#calendly_list_availability_schedules] List availability schedules Notes [#notes] * Category: Scheduling * Authentication mode: OAuth # Canva Integration The Canva integration provides access to list and create Canva designs, manage folders, and export assets through the Integrate MCP server. Installation [#installation] The Canva integration is included with the SDK: ```typescript import { canvaIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Canva OAuth App [#1-create-a-canva-oauth-app] 1. Create an OAuth application for Canva 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Canva integration to your server configuration. The integration automatically reads `CANVA_CLIENT_ID` and `CANVA_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, canvaIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ canvaIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript canvaIntegration({ clientId: process.env.CUSTOM_CANVA_ID, clientSecret: process.env.CUSTOM_CANVA_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("canva"); const result = await client.canva.getMe({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, canvaIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [canvaIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] canva_get_me [#canva_get_me] Get me *No parameters.* canva_get_profile [#canva_get_profile] Get profile *No parameters.* canva_list_designs [#canva_list_designs] List designs canva_get_design [#canva_get_design] Get design canva_get_design_export_formats [#canva_get_design_export_formats] Get design export formats canva_create_design [#canva_create_design] Create design canva_get_folder [#canva_get_folder] Get folder canva_list_folder_items [#canva_list_folder_items] List folder items canva_create_folder [#canva_create_folder] Create folder canva_update_folder [#canva_update_folder] Update folder canva_delete_folder [#canva_delete_folder] Delete folder canva_list_brand_templates [#canva_list_brand_templates] List brand templates canva_get_brand_template [#canva_get_brand_template] Get brand template canva_create_export_job [#canva_create_export_job] Create export job canva_get_export_job [#canva_get_export_job] Get export job Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Canvas LMS Integration The Canvas LMS integration provides access to manage Canvas LMS list courses, get course, list assignments, create assignment, list submissions through the Integrate MCP server. Installation [#installation] The Canvas LMS integration is included with the SDK: ```typescript import { canvasLmsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Canvas LMS OAuth App [#1-create-a-canvas-lms-oauth-app] 1. Create an OAuth application for Canvas LMS 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Canvas LMS integration to your server configuration. The integration automatically reads `CANVAS_LMS_CLIENT_ID` and `CANVAS_LMS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, canvasLmsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ canvasLmsIntegration({ scopes: ["url:GET|/api/v1/courses", "url:GET|/api/v1/users/:id/profile", "url:POST|/api/v1/courses/:course_id/assignments"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript canvasLmsIntegration({ clientId: process.env.CUSTOM_CANVAS_LMS_ID, clientSecret: process.env.CUSTOM_CANVAS_LMS_SECRET, scopes: ["url:GET|/api/v1/courses", "url:GET|/api/v1/users/:id/profile", "url:POST|/api/v1/courses/:course_id/assignments"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("canvas_lms"); const result = await client.canvas_lms.listCourses({ canvas_domain: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, canvasLmsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [canvasLmsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `url:GET|/api/v1/courses` * `url:GET|/api/v1/users/:id/profile` * `url:POST|/api/v1/courses/:course_id/assignments` Tools [#tools] canvas_lms_list_courses [#canvas_lms_list_courses] Lms list courses canvas_lms_get_course [#canvas_lms_get_course] Lms get course canvas_lms_list_assignments [#canvas_lms_list_assignments] Lms list assignments canvas_lms_create_assignment [#canvas_lms_create_assignment] Lms create assignment canvas_lms_list_submissions [#canvas_lms_list_submissions] Lms list submissions canvas_lms_list_users [#canvas_lms_list_users] Lms list users Notes [#notes] * Category: Education * Authentication mode: OAuth # Clerk Integration The Clerk integration provides access to manage Clerk users, organizations, sessions, and authentication settings through the Integrate MCP server. Installation [#installation] The Clerk integration is included with the SDK: ```typescript import { clerkIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Clerk to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, clerkIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ clerkIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.clerk.listUsers({}); console.log(result); ``` Environment Variables [#environment-variables] * `CLERK_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] clerk_list_users [#clerk_list_users] List users clerk_get_user [#clerk_get_user] Get user clerk_create_user [#clerk_create_user] Create user clerk_update_user [#clerk_update_user] Update user clerk_delete_user [#clerk_delete_user] Delete user clerk_list_organizations [#clerk_list_organizations] List organizations clerk_get_organization [#clerk_get_organization] Get organization clerk_create_organization [#clerk_create_organization] Create organization clerk_update_organization [#clerk_update_organization] Update organization clerk_delete_organization [#clerk_delete_organization] Delete organization clerk_list_sessions [#clerk_list_sessions] List sessions clerk_get_session [#clerk_get_session] Get session clerk_revoke_session [#clerk_revoke_session] Revoke session Notes [#notes] * Category: Identity & Access * Authentication mode: API key # ClickUp Integration The ClickUp integration provides access to manage ClickUp tasks, lists, spaces, and workspaces through the Integrate MCP server. Installation [#installation] The ClickUp integration is included with the SDK: ```typescript import { clickupIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a ClickUp OAuth App [#1-create-a-clickup-oauth-app] 1. Go to [App Developer Portal](https://app.clickup.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the ClickUp integration to your server configuration. The integration automatically reads `CLICKUP_CLIENT_ID` and `CLICKUP_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, clickupIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ clickupIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript clickupIntegration({ clientId: process.env.CUSTOM_CLICKUP_ID, clientSecret: process.env.CUSTOM_CLICKUP_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("clickup"); // Use client.clickup methods after connecting ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, clickupIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [clickupIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] clickup_get_authorized_user [#clickup_get_authorized_user] Get authorized user *No parameters.* clickup_list_teams [#clickup_list_teams] List teams *No parameters.* clickup_list_spaces [#clickup_list_spaces] List spaces *No parameters.* clickup_list_folders [#clickup_list_folders] List folders *No parameters.* clickup_list_lists_in_folder [#clickup_list_lists_in_folder] List lists in folder *No parameters.* clickup_list_folderless_lists [#clickup_list_folderless_lists] List folderless lists *No parameters.* clickup_list_tasks [#clickup_list_tasks] List tasks *No parameters.* clickup_get_task [#clickup_get_task] Get task *No parameters.* clickup_create_task [#clickup_create_task] Create task *No parameters.* clickup_update_task [#clickup_update_task] Update task *No parameters.* clickup_delete_task [#clickup_delete_task] Delete task *No parameters.* clickup_list_task_comments [#clickup_list_task_comments] List task comments *No parameters.* clickup_create_task_comment [#clickup_create_task_comment] Create task comment *No parameters.* Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Cloudflare Integration The Cloudflare integration provides access to manage Cloudflare zones, DNS, cache, and Workers via the Cloudflare API through the Integrate MCP server. Installation [#installation] The Cloudflare integration is included with the SDK: ```typescript import { cloudflareIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Cloudflare to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, cloudflareIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ cloudflareIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.cloudflare.verifyToken({}); console.log(result); ``` Environment Variables [#environment-variables] * `CLOUDFLARE_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `account:read` * `user:read` * `zone:read` * `workers:read` * `workers:write` * `pages:write` * `offline_access` Tools [#tools] cloudflare_verify_token [#cloudflare_verify_token] Verify token *No parameters.* cloudflare_get_user [#cloudflare_get_user] Get user *No parameters.* cloudflare_list_accounts [#cloudflare_list_accounts] List accounts cloudflare_get_account [#cloudflare_get_account] Get account cloudflare_list_zones [#cloudflare_list_zones] List zones cloudflare_get_zone [#cloudflare_get_zone] Get zone cloudflare_list_dns_records [#cloudflare_list_dns_records] List dns records cloudflare_create_dns_record [#cloudflare_create_dns_record] Create dns record cloudflare_update_dns_record [#cloudflare_update_dns_record] Update dns record cloudflare_delete_dns_record [#cloudflare_delete_dns_record] Delete dns record cloudflare_purge_zone_cache [#cloudflare_purge_zone_cache] Purge zone cache cloudflare_list_worker_scripts [#cloudflare_list_worker_scripts] List worker scripts Notes [#notes] * Category: Infrastructure * Authentication mode: API key # Confluence Cloud Integration The Confluence Cloud integration provides access to manage Confluence spaces, pages, search, comments, and attachments through the Integrate MCP server. Installation [#installation] The Confluence Cloud integration is included with the SDK: ```typescript import { confluenceIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Confluence Cloud OAuth App [#1-create-a-confluence-cloud-oauth-app] 1. Go to [Auth Developer Portal](https://auth.atlassian.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Confluence Cloud integration to your server configuration. The integration automatically reads `CONFLUENCE_CLIENT_ID` and `CONFLUENCE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, confluenceIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ confluenceIntegration({ scopes: ["read:confluence-content.all", "write:confluence-content", "read:confluence-space.summary", "read:confluence-props", "offline_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript confluenceIntegration({ clientId: process.env.CUSTOM_CONFLUENCE_ID, clientSecret: process.env.CUSTOM_CONFLUENCE_SECRET, scopes: ["read:confluence-content.all", "write:confluence-content", "read:confluence-space.summary", "read:confluence-props", "offline_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("confluence"); const result = await client.confluence.listAccessibleResources({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, confluenceIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [confluenceIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `read:confluence-content.all` * `write:confluence-content` * `read:confluence-space.summary` * `read:confluence-props` * `offline_access` Tools [#tools] confluence_list_accessible_resources [#confluence_list_accessible_resources] List accessible resources *No parameters.* confluence_list_spaces [#confluence_list_spaces] List spaces confluence_get_space [#confluence_get_space] Get space confluence_list_pages [#confluence_list_pages] List pages confluence_get_page [#confluence_get_page] Get page confluence_create_page [#confluence_create_page] Create page confluence_update_page [#confluence_update_page] Update page confluence_delete_page [#confluence_delete_page] Delete page confluence_search [#confluence_search] Search confluence_list_comments [#confluence_list_comments] List comments confluence_create_comment [#confluence_create_comment] Create comment confluence_list_attachments [#confluence_list_attachments] List attachments Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Contentful Integration The Contentful integration provides access to manage Contentful list spaces, get space, list entries, get entry, create entry through the Integrate MCP server. Installation [#installation] The Contentful integration is included with the SDK: ```typescript import { contentfulIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Contentful OAuth App [#1-create-a-contentful-oauth-app] 1. Create an OAuth application for Contentful 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Contentful integration to your server configuration. The integration automatically reads `CONTENTFUL_CLIENT_ID` and `CONTENTFUL_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, contentfulIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ contentfulIntegration({ scopes: ["content_management_manage"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript contentfulIntegration({ clientId: process.env.CUSTOM_CONTENTFUL_ID, clientSecret: process.env.CUSTOM_CONTENTFUL_SECRET, scopes: ["content_management_manage"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("contentful"); const result = await client.contentful.listSpaces({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, contentfulIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [contentfulIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `content_management_manage` Tools [#tools] contentful_list_spaces [#contentful_list_spaces] List spaces contentful_get_space [#contentful_get_space] Get space contentful_list_entries [#contentful_list_entries] List entries contentful_get_entry [#contentful_get_entry] Get entry contentful_create_entry [#contentful_create_entry] Create entry contentful_publish_entry [#contentful_publish_entry] Publish entry Notes [#notes] * Category: Websites & CMS * Authentication mode: OAuth # Convex Integration The Convex integration provides access to manage Convex projects, deployments, regions, classes, and environment variables through the Integrate MCP server. Installation [#installation] The Convex integration is included with the SDK: ```typescript import { convexIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Convex to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, convexIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ convexIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.convex.managementTokenDetails({}); console.log(result); ``` Environment Variables [#environment-variables] * `CONVEX_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] convex_management_token_details [#convex_management_token_details] Management token details *No parameters.* convex_management_list_projects [#convex_management_list_projects] Management list projects convex_management_create_project [#convex_management_create_project] Management create project convex_management_get_project [#convex_management_get_project] Management get project convex_management_delete_project [#convex_management_delete_project] Management delete project convex_management_list_deployments [#convex_management_list_deployments] Management list deployments convex_management_list_team_deployments [#convex_management_list_team_deployments] Management list team deployments convex_management_get_deployment [#convex_management_get_deployment] Management get deployment convex_management_create_deployment [#convex_management_create_deployment] Management create deployment convex_management_update_deployment [#convex_management_update_deployment] Management update deployment convex_management_delete_deployment [#convex_management_delete_deployment] Management delete deployment convex_management_list_deployment_regions [#convex_management_list_deployment_regions] Management list deployment regions *No parameters.* convex_management_list_deployment_classes [#convex_management_list_deployment_classes] Management list deployment classes *No parameters.* convex_management_list_default_environment_variables [#convex_management_list_default_environment_variables] Management list default environment variables convex_management_update_default_environment_variables [#convex_management_update_default_environment_variables] Management update default environment variables convex_deployment_list_environment_variables [#convex_deployment_list_environment_variables] Deployment list environment variables convex_deployment_update_environment_variables [#convex_deployment_update_environment_variables] Deployment update environment variables Notes [#notes] * Category: Engineering * Authentication mode: API key # Cursor Integration The Cursor integration provides access to manage Cursor Cloud Agents and background tasks through the Integrate MCP server. Installation [#installation] The Cursor integration is included with the SDK: ```typescript import { cursorIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Cursor to your server configuration: ```typescript import { createMCPServer, cursorIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ cursorIntegration(), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.cursor.listAgents({}); console.log(result); ``` Configuration Options [#configuration-options] Tools [#tools] cursor_list_agents [#cursor_list_agents] List all cloud agents cursor_get_agent [#cursor_get_agent] Get agent status cursor_get_conversation [#cursor_get_conversation] Get conversation history cursor_launch_agent [#cursor_launch_agent] Launch a new agent cursor_followup_agent [#cursor_followup_agent] Add follow-up instruction cursor_stop_agent [#cursor_stop_agent] Stop a running agent cursor_delete_agent [#cursor_delete_agent] Delete an agent cursor_get_me [#cursor_get_me] Get API key info *No parameters.* cursor_list_models [#cursor_list_models] List available models cursor_list_repositories [#cursor_list_repositories] List GitHub repositories Notes [#notes] * Category: Engineering * Authentication mode: None # Databricks Integration The Databricks integration provides access to run Databricks jobs, list clusters and SQL warehouses, and inspect workspace paths through the Integrate MCP server. Installation [#installation] The Databricks integration is included with the SDK: ```typescript import { databricksIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Databricks OAuth App [#1-create-a-databricks-oauth-app] 1. Create an OAuth application for Databricks 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Databricks integration to your server configuration. The integration automatically reads `DATABRICKS_CLIENT_ID` and `DATABRICKS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, databricksIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ databricksIntegration({ scopes: ["all-apis", "offline_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript databricksIntegration({ clientId: process.env.CUSTOM_DATABRICKS_ID, clientSecret: process.env.CUSTOM_DATABRICKS_SECRET, scopes: ["all-apis", "offline_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("databricks"); const result = await client.databricks.currentUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, databricksIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [databricksIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `all-apis` * `offline_access` Tools [#tools] databricks_current_user [#databricks_current_user] Current user databricks_clusters_list [#databricks_clusters_list] Clusters list databricks_clusters_get [#databricks_clusters_get] Clusters get databricks_jobs_list [#databricks_jobs_list] Jobs list databricks_jobs_get [#databricks_jobs_get] Jobs get databricks_jobs_run_now [#databricks_jobs_run_now] Jobs run now databricks_sql_warehouses_list [#databricks_sql_warehouses_list] Sql warehouses list databricks_workspace_get_status [#databricks_workspace_get_status] Workspace get status Notes [#notes] * Category: Engineering * Authentication mode: OAuth # Datadog Integration The Datadog integration provides access to monitor Datadog metrics, logs, dashboards, and alerts through the Integrate MCP server. Installation [#installation] The Datadog integration is included with the SDK: ```typescript import { datadogIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Datadog to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, datadogIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ datadogIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.datadog.listMonitors({}); console.log(result); ``` Environment Variables [#environment-variables] * `DATADOG_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `monitors_read` * `dashboards_read` * `metrics_read` * `logs_read_data` Tools [#tools] datadog_list_monitors [#datadog_list_monitors] List monitors datadog_get_monitor [#datadog_get_monitor] Get monitor datadog_list_dashboards [#datadog_list_dashboards] List dashboards datadog_get_dashboard [#datadog_get_dashboard] Get dashboard datadog_search_logs [#datadog_search_logs] Search logs Notes [#notes] * Category: Engineering * Authentication mode: API key # Deezer Integration The Deezer integration provides access to manage Deezer get user, search, get album, get track, list playlists through the Integrate MCP server. Installation [#installation] The Deezer integration is included with the SDK: ```typescript import { deezerIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Deezer OAuth App [#1-create-a-deezer-oauth-app] 1. Create an OAuth application for Deezer 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Deezer integration to your server configuration. The integration automatically reads `DEEZER_CLIENT_ID` and `DEEZER_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, deezerIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ deezerIntegration({ scopes: ["basic_access", "email", "manage_library", "delete_library", "listening_history", "offline_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript deezerIntegration({ clientId: process.env.CUSTOM_DEEZER_ID, clientSecret: process.env.CUSTOM_DEEZER_SECRET, scopes: ["basic_access", "email", "manage_library", "delete_library", "listening_history", "offline_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("deezer"); const result = await client.deezer.getUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, deezerIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [deezerIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `basic_access` * `email` * `manage_library` * `delete_library` * `listening_history` * `offline_access` Tools [#tools] deezer_get_user [#deezer_get_user] Get user *No parameters.* deezer_search [#deezer_search] Search deezer_get_album [#deezer_get_album] Get album deezer_get_track [#deezer_get_track] Get track deezer_list_playlists [#deezer_list_playlists] List playlists deezer_add_track_to_playlist [#deezer_add_track_to_playlist] Add track to playlist Notes [#notes] * Category: Entertainment * Authentication mode: OAuth # Default (server) The default server integration provides access to server-level tools that don't belong to a specific integration. These tools are always available on both the client and server without any configuration. Installation [#installation] The server namespace is automatically included with the SDK - no installation needed. It's always available on all MCP clients: ```typescript import { client } from "integrate-sdk"; // Server namespace is always available const tools = await client.server.listToolsByIntegration({ integration: "github", }); ``` Setup [#setup] No Configuration Required [#no-configuration-required] Unlike other integrations, the server namespace requires no setup or configuration. It's automatically included in both: * **MCP Client** - Available via `client.server.*` on all clients * **MCP Server** - Automatically handles server-level tool calls Client-Side Usage [#client-side-usage] The default client automatically includes the server namespace. You can use it directly: ```typescript import { client } from "integrate-sdk"; const tools = await client.server.listToolsByIntegration({ integration: "github", }); ``` If you're using a custom client, the server namespace is still always available: ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [githubIntegration()], }); // Server namespace is always available, even on custom clients const tools = await customClient.server.listToolsByIntegration({ integration: "github", }); ``` Server-Side Usage [#server-side-usage] When using the server client, the server namespace is also available: ```typescript import { createMCPServer, githubIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [githubIntegration()], }); // Server namespace works on server clients too const tools = await serverClient.server.listToolsByIntegration({ integration: "github", }); ``` Available Tools [#available-tools] Tool Discovery [#tool-discovery] * **`listAllProviders`** - List all providers available on the MCP server * **`listToolsByIntegration`** - List all tools available for a specific integration * **`listConfiguredIntegrations`** - List integrations configured for this application Examples [#examples] List All Providers [#list-all-providers] ```typescript // List all available providers on the MCP server const result = await client.server.listAllProviders(); console.log("All providers:", result); ``` List Tools for an Integration [#list-tools-for-an-integration] ```typescript // List all available GitHub tools const result = await client.server.listToolsByIntegration({ integration: "github", }); console.log("GitHub tools:", result); ``` Discover Available Integrations [#discover-available-integrations] You can use this tool to discover what tools are available for any integration: ```typescript // Check what Gmail tools are available const gmailTools = await client.server.listToolsByIntegration({ integration: "gmail", }); // Check what Notion tools are available const notionTools = await client.server.listToolsByIntegration({ integration: "notion", }); console.log("Gmail tools:", gmailTools); console.log("Notion tools:", notionTools); ``` List Configured Integrations [#list-configured-integrations] Get a list of integrations configured for your application. The behavior depends on how you created your client: **Default Client** - Fetches from server: When using the default exported client (`import { client } from 'integrate-sdk'`), this method queries the server to get the list of integrations actually configured with OAuth credentials via `createMCPServer()`: ```typescript import { client } from "integrate-sdk"; // Fetches from server to get what's actually configured const { integrations } = await client.server.listConfiguredIntegrations(); console.log(`Server has ${integrations.length} integrations configured:`); integrations.forEach((integration) => { console.log(`- ${integration.name} (${integration.id})`); console.log(` OAuth: ${integration.hasOAuth ? 'Yes' : 'No'}`); }); ``` **Custom Client** - Uses local config: When using a custom client created via `createMCPClient()`, this method returns the integrations you explicitly configured (no server call): ```typescript import { createMCPClient, githubIntegration, gmailIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [githubIntegration(), gmailIntegration()], }); // Returns local config - no server call const { integrations } = await customClient.server.listConfiguredIntegrations(); // Returns github and gmail (what you configured) ``` **Server Client** - Uses local config: Server clients always return their local configuration (they ARE the server): ```typescript import { createMCPServer, githubIntegration } from "integrate-sdk/server"; const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [githubIntegration({ clientId: "...", clientSecret: "..." })], }); // Returns local config const { integrations } = await serverClient.server.listConfiguredIntegrations(); ``` **With full tool metadata:** If you need tool descriptions and input schemas, use the `includeToolMetadata` option. This fetches metadata for all integrations using batched requests with concurrency control to avoid rate limiting: ```typescript // Complete: Get configured integrations with full tool metadata const { integrations } = await client.server.listConfiguredIntegrations({ includeToolMetadata: true, }); integrations.forEach((integration) => { console.log(`${integration.name}:`); integration.toolMetadata?.forEach((tool) => { console.log(` - ${tool.name}: ${tool.description}`); if (tool.inputSchema?.required) { console.log(` Required fields: ${tool.inputSchema.required.join(', ')}`); } }); }); ``` **Response format (basic):** ```typescript { integrations: [ { id: "github", name: "GitHub", description: "Manage GitHub repos, issues, and pull requests", category: "Engineering", tools: ["github_create_issue", "github_list_repos", ...], hasOAuth: true, scopes: ["repo", "user"], provider: "github" }, { id: "gmail", name: "Gmail", description: "Send, read, and search Gmail messages", category: "Communication", tools: ["gmail_send_email", "gmail_list_messages", ...], hasOAuth: true, scopes: ["gmail.readonly"], provider: "gmail" } ] } ``` **Response format (with metadata):** ```typescript { integrations: [ { id: "github", name: "GitHub", description: "Manage GitHub repos, issues, and pull requests", category: "Engineering", tools: ["github_create_issue", "github_list_repos", ...], hasOAuth: true, scopes: ["repo", "user"], provider: "github", toolMetadata: [ { name: "github_create_issue", description: "Create a new issue in a GitHub repository", inputSchema: { type: "object", properties: { title: { type: "string" }, body: { type: "string" }, labels: { type: "array" } }, required: ["title"] } }, // ... more tools ] } ] } ``` Dynamic Tool Discovery [#dynamic-tool-discovery] Use this tool to dynamically discover available tools at runtime: ```typescript async function getIntegrationTools(integrationName: string) { try { const result = await client.server.listToolsByIntegration({ integration: integrationName, }); return result; } catch (error) { console.error(`Failed to get tools for ${integrationName}:`, error); return null; } } // Use it to discover tools const githubTools = await getIntegrationTools("github"); const gmailTools = await getIntegrationTools("gmail"); ``` Error Handling [#error-handling] ```typescript try { const result = await client.server.listToolsByIntegration({ integration: "github", }); console.log("Tools:", result); } catch (error) { if (error.message.includes("not found")) { console.error("Integration not found"); } else if (error.message.includes("authentication")) { console.error("Authentication required"); } else { console.error("Unexpected error:", error); } } ``` Next Steps [#next-steps] * Explore the [GitHub Integration](/docs/integrations/github) * Explore the [Gmail Integration](/docs/integrations/gmail) * Learn about [custom integrations](/docs/integrations#custom-integrations) * See [Advanced Usage](/docs/getting-started/advanced-usage) for more examples # DHL Integration The DHL integration provides access to manage DHL track shipment, create shipment, get label, delete shipment, validate address through the Integrate MCP server. Installation [#installation] The DHL integration is included with the SDK: ```typescript import { dhlIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a DHL OAuth App [#1-create-a-dhl-oauth-app] 1. Create an OAuth application for DHL 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the DHL integration to your server configuration. The integration automatically reads `DHL_CLIENT_ID` and `DHL_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, dhlIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ dhlIntegration({ scopes: ["shipping", "tracking"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript dhlIntegration({ clientId: process.env.CUSTOM_DHL_ID, clientSecret: process.env.CUSTOM_DHL_SECRET, scopes: ["shipping", "tracking"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("dhl"); const result = await client.dhl.trackShipment({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, dhlIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [dhlIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `shipping` * `tracking` Tools [#tools] dhl_track_shipment [#dhl_track_shipment] Track shipment dhl_create_shipment [#dhl_create_shipment] Create shipment dhl_get_label [#dhl_get_label] Get label dhl_delete_shipment [#dhl_delete_shipment] Delete shipment dhl_validate_address [#dhl_validate_address] Validate address Notes [#notes] * Category: Shipping & Logistics * Authentication mode: OAuth # Discord Integration The Discord integration provides access to send and manage Discord messages; list guilds and channels (bot token required on server for channel APIs) through the Integrate MCP server. Installation [#installation] The Discord integration is included with the SDK: ```typescript import { discordIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Discord OAuth App [#1-create-a-discord-oauth-app] 1. Go to [Discord Developer Portal](https://discord.com/developers/applications) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Discord integration to your server configuration. The integration automatically reads `DISCORD_CLIENT_ID` and `DISCORD_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, discordIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ discordIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript discordIntegration({ clientId: process.env.CUSTOM_DISCORD_ID, clientSecret: process.env.CUSTOM_DISCORD_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("discord"); const result = await client.discord.getCurrentUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, discordIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [discordIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] discord_get_current_user [#discord_get_current_user] Get current user *No parameters.* discord_list_my_guilds [#discord_list_my_guilds] List my guilds discord_get_guild [#discord_get_guild] Get guild discord_list_guild_channels [#discord_list_guild_channels] List guild channels discord_get_channel [#discord_get_channel] Get channel discord_send_message [#discord_send_message] Send message discord_list_messages [#discord_list_messages] List messages discord_edit_message [#discord_edit_message] Edit message discord_delete_message [#discord_delete_message] Delete message Notes [#notes] * Category: Communication * Authentication mode: OAuth # DocuSign Integration The DocuSign integration provides access to manage DocuSign eSignature accounts, envelopes, recipients, documents, and templates through the Integrate MCP server. Installation [#installation] The DocuSign integration is included with the SDK: ```typescript import { docusignIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a DocuSign OAuth App [#1-create-a-docusign-oauth-app] 1. Create an OAuth application for DocuSign 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the DocuSign integration to your server configuration. The integration automatically reads `DOCUSIGN_CLIENT_ID` and `DOCUSIGN_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, docusignIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ docusignIntegration({ scopes: ["signature", "impersonation"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript docusignIntegration({ clientId: process.env.CUSTOM_DOCUSIGN_ID, clientSecret: process.env.CUSTOM_DOCUSIGN_SECRET, scopes: ["signature", "impersonation"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("docusign"); const result = await client.docusign.getUserInfo({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, docusignIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [docusignIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `signature` * `impersonation` Tools [#tools] docusign_get_user_info [#docusign_get_user_info] Get user info *No parameters.* docusign_list_envelopes [#docusign_list_envelopes] List envelopes docusign_get_envelope [#docusign_get_envelope] Get envelope docusign_create_envelope [#docusign_create_envelope] Create envelope docusign_list_recipients [#docusign_list_recipients] List recipients docusign_get_document [#docusign_get_document] Get document docusign_list_templates [#docusign_list_templates] List templates Notes [#notes] * Category: Legal * Authentication mode: OAuth # Dropbox Integration The Dropbox integration provides access to manage Dropbox files, folders, and sharing through the Integrate MCP server. Installation [#installation] The Dropbox integration is included with the SDK: ```typescript import { dropboxIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Dropbox OAuth App [#1-create-a-dropbox-oauth-app] 1. Create an OAuth application for Dropbox 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Dropbox integration to your server configuration. The integration automatically reads `DROPBOX_CLIENT_ID` and `DROPBOX_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, dropboxIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ dropboxIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript dropboxIntegration({ clientId: process.env.CUSTOM_DROPBOX_ID, clientSecret: process.env.CUSTOM_DROPBOX_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("dropbox"); // Use client.dropbox methods after connecting ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, dropboxIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [dropboxIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] dropbox_get_current_account [#dropbox_get_current_account] Get current account *No parameters.* dropbox_get_space_usage [#dropbox_get_space_usage] Get space usage *No parameters.* dropbox_list_folder [#dropbox_list_folder] List folder *No parameters.* dropbox_list_folder_continue [#dropbox_list_folder_continue] List folder continue *No parameters.* dropbox_get_metadata [#dropbox_get_metadata] Get metadata *No parameters.* dropbox_search_files [#dropbox_search_files] Search files *No parameters.* dropbox_create_folder [#dropbox_create_folder] Create folder *No parameters.* dropbox_delete_path [#dropbox_delete_path] Delete path *No parameters.* dropbox_move_path [#dropbox_move_path] Move path *No parameters.* dropbox_copy_path [#dropbox_copy_path] Copy path *No parameters.* dropbox_upload_text_file [#dropbox_upload_text_file] Upload text file *No parameters.* dropbox_download_file [#dropbox_download_file] Download file *No parameters.* dropbox_get_temporary_link [#dropbox_get_temporary_link] Get temporary link *No parameters.* dropbox_create_shared_link [#dropbox_create_shared_link] Create shared link *No parameters.* dropbox_list_shared_links [#dropbox_list_shared_links] List shared links *No parameters.* dropbox_revoke_shared_link [#dropbox_revoke_shared_link] Revoke shared link *No parameters.* Notes [#notes] * Category: Storage * Authentication mode: OAuth # Dropbox Sign Integration The Dropbox Sign integration provides access to manage Dropbox Sign get account, list signature requests, get signature request, send signature request, list templates through the Integrate MCP server. Installation [#installation] The Dropbox Sign integration is included with the SDK: ```typescript import { dropboxSignIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Dropbox Sign OAuth App [#1-create-a-dropbox-sign-oauth-app] 1. Create an OAuth application for Dropbox Sign 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Dropbox Sign integration to your server configuration. The integration automatically reads `DROPBOX_SIGN_CLIENT_ID` and `DROPBOX_SIGN_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, dropboxSignIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ dropboxSignIntegration({ scopes: ["basic_account_info", "request_signature", "signature_request_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript dropboxSignIntegration({ clientId: process.env.CUSTOM_DROPBOX_SIGN_ID, clientSecret: process.env.CUSTOM_DROPBOX_SIGN_SECRET, scopes: ["basic_account_info", "request_signature", "signature_request_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("dropbox_sign"); const result = await client.dropbox_sign.getAccount({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, dropboxSignIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [dropboxSignIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `basic_account_info` * `request_signature` * `signature_request_access` Tools [#tools] dropbox_sign_get_account [#dropbox_sign_get_account] Sign get account *No parameters.* dropbox_sign_list_signature_requests [#dropbox_sign_list_signature_requests] Sign list signature requests dropbox_sign_get_signature_request [#dropbox_sign_get_signature_request] Sign get signature request dropbox_sign_send_signature_request [#dropbox_sign_send_signature_request] Sign send signature request dropbox_sign_list_templates [#dropbox_sign_list_templates] Sign list templates dropbox_sign_get_template [#dropbox_sign_get_template] Sign get template Notes [#notes] * Category: Legal * Authentication mode: OAuth # eBay Integration The eBay integration provides access to manage eBay browse, inventory, offers, orders, and fulfillment APIs through the Integrate MCP server. Installation [#installation] The eBay integration is included with the SDK: ```typescript import { ebayIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an eBay OAuth App [#1-create-an-ebay-oauth-app] 1. Create an OAuth application for eBay 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the eBay integration to your server configuration. The integration automatically reads `EBAY_CLIENT_ID` and `EBAY_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, ebayIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ ebayIntegration({ scopes: ["https://api.ebay.com/oauth/api_scope", "https://api.ebay.com/oauth/api_scope/sell.inventory", "https://api.ebay.com/oauth/api_scope/sell.fulfillment", "https://api.ebay.com/oauth/api_scope/sell.account"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript ebayIntegration({ clientId: process.env.CUSTOM_EBAY_ID, clientSecret: process.env.CUSTOM_EBAY_SECRET, scopes: ["https://api.ebay.com/oauth/api_scope", "https://api.ebay.com/oauth/api_scope/sell.inventory", "https://api.ebay.com/oauth/api_scope/sell.fulfillment", "https://api.ebay.com/oauth/api_scope/sell.account"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("ebay"); const result = await client.ebay.searchItems({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, ebayIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [ebayIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `https://api.ebay.com/oauth/api_scope` * `https://api.ebay.com/oauth/api_scope/sell.inventory` * `https://api.ebay.com/oauth/api_scope/sell.fulfillment` * `https://api.ebay.com/oauth/api_scope/sell.account` Tools [#tools] ebay_search_items [#ebay_search_items] Search items ebay_get_item [#ebay_get_item] Get item ebay_get_privileges [#ebay_get_privileges] Get privileges *No parameters.* ebay_list_inventory_items [#ebay_list_inventory_items] List inventory items ebay_create_or_replace_inventory_item [#ebay_create_or_replace_inventory_item] Create or replace inventory item ebay_list_offers [#ebay_list_offers] List offers ebay_create_offer [#ebay_create_offer] Create offer ebay_list_orders [#ebay_list_orders] List orders ebay_get_order [#ebay_get_order] Get order Notes [#notes] * Category: Commerce * Authentication mode: OAuth # eToro Integration The eToro integration provides access to access eToro Public API identity, portfolio, market data, trade history, and watchlists through the Integrate MCP server. Installation [#installation] The eToro integration is included with the SDK: ```typescript import { etoroIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add eToro to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, etoroIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ etoroIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.etoro.getIdentity({}); console.log(result); ``` Environment Variables [#environment-variables] * `ETORO_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] etoro_get_identity [#etoro_get_identity] Get identity *No parameters.* etoro_get_portfolio [#etoro_get_portfolio] Get portfolio *No parameters.* etoro_search_instruments [#etoro_search_instruments] Search instruments etoro_get_instrument_rates [#etoro_get_instrument_rates] Get instrument rates etoro_list_trade_history [#etoro_list_trade_history] List trade history etoro_list_watchlists [#etoro_list_watchlists] List watchlists Notes [#notes] * Category: Finance * Authentication mode: API key # Etsy Integration The Etsy integration provides access to manage Etsy get me, get shop, list shop listings, create listing, list receipts through the Integrate MCP server. Installation [#installation] The Etsy integration is included with the SDK: ```typescript import { etsyIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Etsy OAuth App [#1-create-an-etsy-oauth-app] 1. Create an OAuth application for Etsy 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Etsy integration to your server configuration. The integration automatically reads `ETSY_CLIENT_ID` and `ETSY_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, etsyIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ etsyIntegration({ scopes: ["listings_r", "listings_w", "transactions_r", "transactions_w", "shops_r", "shops_w", "profile_r"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript etsyIntegration({ clientId: process.env.CUSTOM_ETSY_ID, clientSecret: process.env.CUSTOM_ETSY_SECRET, scopes: ["listings_r", "listings_w", "transactions_r", "transactions_w", "shops_r", "shops_w", "profile_r"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("etsy"); const result = await client.etsy.getMe({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, etsyIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [etsyIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `listings_r` * `listings_w` * `transactions_r` * `transactions_w` * `shops_r` * `shops_w` * `profile_r` Tools [#tools] etsy_get_me [#etsy_get_me] Get me *No parameters.* etsy_get_shop [#etsy_get_shop] Get shop etsy_list_shop_listings [#etsy_list_shop_listings] List shop listings etsy_create_listing [#etsy_create_listing] Create listing etsy_list_receipts [#etsy_list_receipts] List receipts etsy_update_inventory [#etsy_update_inventory] Update inventory Notes [#notes] * Category: Commerce * Authentication mode: OAuth # Eventbrite Integration The Eventbrite integration provides access to manage Eventbrite get user, list organizations, list events, get event, create event through the Integrate MCP server. Installation [#installation] The Eventbrite integration is included with the SDK: ```typescript import { eventbriteIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Eventbrite OAuth App [#1-create-an-eventbrite-oauth-app] 1. Create an OAuth application for Eventbrite 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Eventbrite integration to your server configuration. The integration automatically reads `EVENTBRITE_CLIENT_ID` and `EVENTBRITE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, eventbriteIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ eventbriteIntegration({ scopes: ["eventbrite"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript eventbriteIntegration({ clientId: process.env.CUSTOM_EVENTBRITE_ID, clientSecret: process.env.CUSTOM_EVENTBRITE_SECRET, scopes: ["eventbrite"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("eventbrite"); const result = await client.eventbrite.getUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, eventbriteIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [eventbriteIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `eventbrite` Tools [#tools] eventbrite_get_user [#eventbrite_get_user] Get user *No parameters.* eventbrite_list_organizations [#eventbrite_list_organizations] List organizations *No parameters.* eventbrite_list_events [#eventbrite_list_events] List events eventbrite_get_event [#eventbrite_get_event] Get event eventbrite_create_event [#eventbrite_create_event] Create event eventbrite_list_attendees [#eventbrite_list_attendees] List attendees Notes [#notes] * Category: Events & Ticketing * Authentication mode: OAuth # Exact Online Integration The Exact Online integration provides access to manage Exact Online list divisions, list accounts, list items, list sales invoices, create sales invoice through the Integrate MCP server. Installation [#installation] The Exact Online integration is included with the SDK: ```typescript import { exactOnlineIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Exact Online OAuth App [#1-create-an-exact-online-oauth-app] 1. Create an OAuth application for Exact Online 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Exact Online integration to your server configuration. The integration automatically reads `EXACT_ONLINE_CLIENT_ID` and `EXACT_ONLINE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, exactOnlineIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ exactOnlineIntegration({ scopes: ["financial", "crm", "sales", "purchase", "offline_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript exactOnlineIntegration({ clientId: process.env.CUSTOM_EXACT_ONLINE_ID, clientSecret: process.env.CUSTOM_EXACT_ONLINE_SECRET, scopes: ["financial", "crm", "sales", "purchase", "offline_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("exact_online"); const result = await client.exact_online.listDivisions({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, exactOnlineIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [exactOnlineIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `financial` * `crm` * `sales` * `purchase` * `offline_access` Tools [#tools] exact_online_list_divisions [#exact_online_list_divisions] Online list divisions *No parameters.* exact_online_list_accounts [#exact_online_list_accounts] Online list accounts exact_online_list_items [#exact_online_list_items] Online list items exact_online_list_sales_invoices [#exact_online_list_sales_invoices] Online list sales invoices exact_online_create_sales_invoice [#exact_online_create_sales_invoice] Online create sales invoice exact_online_list_gl_accounts [#exact_online_list_gl_accounts] Online list gl accounts Notes [#notes] * Category: Accounting * Authentication mode: OAuth # Excel Integration The Excel integration provides access to manage Excel workbooks, worksheets, and tables through the Integrate MCP server. Installation [#installation] The Excel integration is included with the SDK: ```typescript import { excelIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Excel OAuth App [#1-create-an-excel-oauth-app] 1. Go to [Azure Portal β€” App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Excel integration to your server configuration. The integration automatically reads `EXCEL_CLIENT_ID` and `EXCEL_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, excelIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ excelIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript excelIntegration({ clientId: process.env.CUSTOM_EXCEL_ID, clientSecret: process.env.CUSTOM_EXCEL_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("excel"); const result = await client.excel.list({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, excelIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [excelIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] excel_add_table_rows [#excel_add_table_rows] Append rows to a table excel_add_worksheet [#excel_add_worksheet] Add a new worksheet to a workbook excel_clear_range [#excel_clear_range] Clear contents and/or formatting from a cell range excel_create [#excel_create] Create a new empty .xlsx workbook in OneDrive excel_create_table [#excel_create_table] Create a table from a cell range excel_delete [#excel_delete] Delete an Excel workbook permanently excel_delete_worksheet [#excel_delete_worksheet] Delete a worksheet from a workbook excel_get [#excel_get] Get metadata for an Excel workbook excel_get_range [#excel_get_range] Get values, formulas, and formatting from a cell range excel_get_table_rows [#excel_get_table_rows] Get rows from a table excel_get_used_range [#excel_get_used_range] Get the bounding range of all data in a worksheet excel_list [#excel_list] Search for Excel workbooks excel_list_tables [#excel_list_tables] List all tables in a worksheet excel_list_worksheets [#excel_list_worksheets] List all worksheets in a workbook excel_share [#excel_share] Create a sharing link for an Excel workbook excel_update_range [#excel_update_range] Update cell values in a range Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Expedia Rapid Integration The Expedia Rapid integration provides access to manage Expedia Rapid search properties, get property content, get rate quote, create booking, get itinerary through the Integrate MCP server. Installation [#installation] The Expedia Rapid integration is included with the SDK: ```typescript import { expediaIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Expedia Rapid OAuth App [#1-create-an-expedia-rapid-oauth-app] 1. Create an OAuth application for Expedia Rapid 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Expedia Rapid integration to your server configuration. The integration automatically reads `EXPEDIA_CLIENT_ID` and `EXPEDIA_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, expediaIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ expediaIntegration({ scopes: ["rapid"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript expediaIntegration({ clientId: process.env.CUSTOM_EXPEDIA_ID, clientSecret: process.env.CUSTOM_EXPEDIA_SECRET, scopes: ["rapid"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("expedia"); const result = await client.expedia.searchProperties({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, expediaIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [expediaIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `rapid` Tools [#tools] expedia_search_properties [#expedia_search_properties] Search properties expedia_get_property_content [#expedia_get_property_content] Get property content expedia_get_rate_quote [#expedia_get_rate_quote] Get rate quote expedia_create_booking [#expedia_create_booking] Create booking expedia_get_itinerary [#expedia_get_itinerary] Get itinerary Notes [#notes] * Category: Travel * Authentication mode: OAuth # Facebook Integration The Facebook integration provides access to manage Facebook Page posts, comments, reactions, and insights via the Graph API through the Integrate MCP server. Installation [#installation] The Facebook integration is included with the SDK: ```typescript import { facebookIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Facebook OAuth App [#1-create-a-facebook-oauth-app] 1. Go to [Facebook Developer Portal](https://www.facebook.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Facebook integration to your server configuration. The integration automatically reads `FACEBOOK_CLIENT_ID` and `FACEBOOK_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, facebookIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ facebookIntegration({ scopes: ["public_profile", "email", "pages_show_list", "pages_read_engagement", "pages_manage_posts", "pages_read_user_content", "pages_manage_engagement"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript facebookIntegration({ clientId: process.env.CUSTOM_FACEBOOK_ID, clientSecret: process.env.CUSTOM_FACEBOOK_SECRET, scopes: ["public_profile", "email", "pages_show_list", "pages_read_engagement", "pages_manage_posts", "pages_read_user_content", "pages_manage_engagement"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("facebook"); const result = await client.facebook.getMe({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, facebookIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [facebookIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `public_profile` * `email` * `pages_show_list` * `pages_read_engagement` * `pages_manage_posts` * `pages_read_user_content` * `pages_manage_engagement` Tools [#tools] facebook_get_me [#facebook_get_me] Get me facebook_list_pages [#facebook_list_pages] List pages facebook_list_page_posts [#facebook_list_page_posts] List page posts facebook_get_object [#facebook_get_object] Get object facebook_create_page_post [#facebook_create_page_post] Create page post facebook_delete_object [#facebook_delete_object] Delete object facebook_list_comments [#facebook_list_comments] List comments facebook_publish_comment [#facebook_publish_comment] Publish comment facebook_get_insights [#facebook_get_insights] Get insights facebook_set_comment_visibility [#facebook_set_comment_visibility] Set comment visibility facebook_like_object [#facebook_like_object] Like object Notes [#notes] * Category: Social Media * Authentication mode: OAuth # FedEx Integration The FedEx integration provides access to manage FedEx track shipments, rate shipment, create shipment, cancel shipment, validate address through the Integrate MCP server. Installation [#installation] The FedEx integration is included with the SDK: ```typescript import { fedexIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a FedEx OAuth App [#1-create-a-fedex-oauth-app] 1. Create an OAuth application for FedEx 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the FedEx integration to your server configuration. The integration automatically reads `FEDEX_CLIENT_ID` and `FEDEX_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, fedexIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ fedexIntegration({ scopes: ["ship", "track", "rates", "address"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript fedexIntegration({ clientId: process.env.CUSTOM_FEDEX_ID, clientSecret: process.env.CUSTOM_FEDEX_SECRET, scopes: ["ship", "track", "rates", "address"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("fedex"); const result = await client.fedex.trackShipments({ tracking_json: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, fedexIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [fedexIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ship` * `track` * `rates` * `address` Tools [#tools] fedex_track_shipments [#fedex_track_shipments] Track shipments fedex_rate_shipment [#fedex_rate_shipment] Rate shipment fedex_create_shipment [#fedex_create_shipment] Create shipment fedex_cancel_shipment [#fedex_cancel_shipment] Cancel shipment fedex_validate_address [#fedex_validate_address] Validate address Notes [#notes] * Category: Shipping & Logistics * Authentication mode: OAuth # Figma Integration The Figma integration provides access to access Figma files, comments, and components through the Integrate MCP server. Installation [#installation] The Figma integration is included with the SDK: ```typescript import { figmaIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Figma OAuth App [#1-create-a-figma-oauth-app] 1. Go to [Figma for Developers](https://www.figma.com/developers/apps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Figma integration to your server configuration. The integration automatically reads `FIGMA_CLIENT_ID` and `FIGMA_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, figmaIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ figmaIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript figmaIntegration({ clientId: process.env.CUSTOM_FIGMA_ID, clientSecret: process.env.CUSTOM_FIGMA_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("figma"); const result = await client.figma.getFile({ file_key: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, figmaIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [figmaIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] figma_get_file [#figma_get_file] Get a Figma file by key figma_get_file_nodes [#figma_get_file_nodes] Get specific nodes from a file figma_get_file_meta [#figma_get_file_meta] Get file metadata (name, last modified, version, etc.) without the full document tree figma_get_image_fills [#figma_get_image_fills] Get URLs of image fills used in a file figma_get_images [#figma_get_images] Export rendered images for nodes in a file figma_get_file_versions [#figma_get_file_versions] Get version history of a file figma_get_oembed [#figma_get_oembed] Get oEmbed data for a Figma file (embed metadata for external sites) figma_get_me [#figma_get_me] Get the current authenticated user *No parameters.* figma_get_comments [#figma_get_comments] Get comments on a file figma_post_comment [#figma_post_comment] Post a comment on a file figma_delete_comment [#figma_delete_comment] Delete a comment from a file figma_get_comment_reactions [#figma_get_comment_reactions] Get reactions on a comment figma_post_comment_reaction [#figma_post_comment_reaction] Add a reaction to a comment figma_delete_comment_reaction [#figma_delete_comment_reaction] Delete a reaction from a comment figma_list_projects [#figma_list_projects] List projects in a team figma_get_project_files [#figma_get_project_files] Get files in a project figma_get_team_components [#figma_get_team_components] Get published components for a team figma_get_file_components [#figma_get_file_components] Get components defined in a file figma_get_component [#figma_get_component] Get a single published component by key figma_get_team_component_sets [#figma_get_team_component_sets] Get published component sets for a team figma_get_file_component_sets [#figma_get_file_component_sets] Get component sets defined in a file figma_get_component_set [#figma_get_component_set] Get a single published component set by key figma_get_team_styles [#figma_get_team_styles] Get published styles for a team figma_get_file_styles [#figma_get_file_styles] Get styles defined in a file figma_get_style [#figma_get_style] Get a single published style by key figma_list_webhooks [#figma_list_webhooks] List all webhooks for the authenticated user figma_create_webhook [#figma_create_webhook] Create a webhook figma_get_webhook [#figma_get_webhook] Get a webhook by ID figma_update_webhook [#figma_update_webhook] Update an existing webhook figma_delete_webhook [#figma_delete_webhook] Delete a webhook figma_get_team_webhooks [#figma_get_team_webhooks] Get all webhooks for a team figma_get_webhook_requests [#figma_get_webhook_requests] Get recent delivery requests for a webhook figma_get_local_variables [#figma_get_local_variables] Get local variables defined in a file figma_get_published_variables [#figma_get_published_variables] Get published variables available to a file figma_post_variables [#figma_post_variables] Create, update, or delete variables and variable collections in a file figma_get_dev_resources [#figma_get_dev_resources] Get dev resources linked to nodes in a file figma_post_dev_resources [#figma_post_dev_resources] Create dev resources linked to file nodes figma_put_dev_resources [#figma_put_dev_resources] Update existing dev resources figma_delete_dev_resource [#figma_delete_dev_resource] Delete a dev resource from a file figma_get_payments [#figma_get_payments] Get payment status for a plugin, widget, or community file. figma_get_library_analytics_component_actions [#figma_get_library_analytics_component_actions] Get analytics on component insert/detach actions from a library file figma_get_library_analytics_component_usages [#figma_get_library_analytics_component_usages] Get analytics on component usages (instances) from a library file figma_get_library_analytics_style_actions [#figma_get_library_analytics_style_actions] Get analytics on style insert/detach actions from a library file figma_get_library_analytics_style_usages [#figma_get_library_analytics_style_usages] Get analytics on style usages from a library file Notes [#notes] * Category: Engineering * Authentication mode: OAuth # Firebase Integration The Firebase integration provides access to manage Firebase projects and registered apps across web, Android, and Apple platforms through the Integrate MCP server. Installation [#installation] The Firebase integration is included with the SDK: ```typescript import { firebaseIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Firebase OAuth App [#1-create-a-firebase-oauth-app] 1. Create an OAuth application for Firebase 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Firebase integration to your server configuration. The integration automatically reads `FIREBASE_CLIENT_ID` and `FIREBASE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, firebaseIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ firebaseIntegration({ scopes: ["openid", "email", "https://www.googleapis.com/auth/firebase", "https://www.googleapis.com/auth/cloud-platform"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript firebaseIntegration({ clientId: process.env.CUSTOM_FIREBASE_ID, clientSecret: process.env.CUSTOM_FIREBASE_SECRET, scopes: ["openid", "email", "https://www.googleapis.com/auth/firebase", "https://www.googleapis.com/auth/cloud-platform"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("firebase"); const result = await client.firebase.listProjects({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, firebaseIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [firebaseIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `openid` * `email` * `https://www.googleapis.com/auth/firebase` * `https://www.googleapis.com/auth/cloud-platform` Tools [#tools] firebase_list_projects [#firebase_list_projects] List projects firebase_get_project [#firebase_get_project] Get project firebase_list_web_apps [#firebase_list_web_apps] List web apps firebase_list_android_apps [#firebase_list_android_apps] List android apps firebase_list_ios_apps [#firebase_list_ios_apps] List ios apps firebase_create_web_app [#firebase_create_web_app] Create web app Notes [#notes] * Category: Infrastructure * Authentication mode: OAuth # Fitbit Integration The Fitbit integration provides access to manage Fitbit get profile, list activities, list sleep, list heart rate, list weight through the Integrate MCP server. Installation [#installation] The Fitbit integration is included with the SDK: ```typescript import { fitbitIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Fitbit OAuth App [#1-create-a-fitbit-oauth-app] 1. Create an OAuth application for Fitbit 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Fitbit integration to your server configuration. The integration automatically reads `FITBIT_CLIENT_ID` and `FITBIT_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, fitbitIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ fitbitIntegration({ scopes: ["activity", "heartrate", "location", "nutrition", "profile", "settings", "sleep", "social", "weight"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript fitbitIntegration({ clientId: process.env.CUSTOM_FITBIT_ID, clientSecret: process.env.CUSTOM_FITBIT_SECRET, scopes: ["activity", "heartrate", "location", "nutrition", "profile", "settings", "sleep", "social", "weight"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("fitbit"); const result = await client.fitbit.getProfile({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, fitbitIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [fitbitIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `activity` * `heartrate` * `location` * `nutrition` * `profile` * `settings` * `sleep` * `social` * `weight` Tools [#tools] fitbit_get_profile [#fitbit_get_profile] Get profile *No parameters.* fitbit_list_activities [#fitbit_list_activities] List activities fitbit_list_sleep [#fitbit_list_sleep] List sleep fitbit_list_heart_rate [#fitbit_list_heart_rate] List heart rate fitbit_list_weight [#fitbit_list_weight] List weight fitbit_log_activity [#fitbit_log_activity] Log activity Notes [#notes] * Category: Fitness * Authentication mode: OAuth # Foursquare Integration The Foursquare integration provides access to manage Foursquare search places, get place, get place tips, get place photos, autocomplete places through the Integrate MCP server. Installation [#installation] The Foursquare integration is included with the SDK: ```typescript import { foursquareIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Foursquare OAuth App [#1-create-a-foursquare-oauth-app] 1. Create an OAuth application for Foursquare 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Foursquare integration to your server configuration. The integration automatically reads `FOURSQUARE_CLIENT_ID` and `FOURSQUARE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, foursquareIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ foursquareIntegration({ scopes: ["places", "tips", "photos"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript foursquareIntegration({ clientId: process.env.CUSTOM_FOURSQUARE_ID, clientSecret: process.env.CUSTOM_FOURSQUARE_SECRET, scopes: ["places", "tips", "photos"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("foursquare"); const result = await client.foursquare.searchPlaces({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, foursquareIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [foursquareIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `places` * `tips` * `photos` Tools [#tools] foursquare_search_places [#foursquare_search_places] Search places foursquare_get_place [#foursquare_get_place] Get place foursquare_get_place_tips [#foursquare_get_place_tips] Get place tips foursquare_get_place_photos [#foursquare_get_place_photos] Get place photos foursquare_autocomplete_places [#foursquare_autocomplete_places] Autocomplete places Notes [#notes] * Category: Food * Authentication mode: OAuth # FreeAgent Integration The FreeAgent integration provides access to manage FreeAgent get company, list contacts, create contact, list invoices, create invoice through the Integrate MCP server. Installation [#installation] The FreeAgent integration is included with the SDK: ```typescript import { freeagentIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a FreeAgent OAuth App [#1-create-a-freeagent-oauth-app] 1. Create an OAuth application for FreeAgent 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the FreeAgent integration to your server configuration. The integration automatically reads `FREEAGENT_CLIENT_ID` and `FREEAGENT_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, freeagentIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ freeagentIntegration({ scopes: ["full_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript freeagentIntegration({ clientId: process.env.CUSTOM_FREEAGENT_ID, clientSecret: process.env.CUSTOM_FREEAGENT_SECRET, scopes: ["full_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("freeagent"); const result = await client.freeagent.getCompany({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, freeagentIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [freeagentIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `full_access` Tools [#tools] freeagent_get_company [#freeagent_get_company] Get company *No parameters.* freeagent_list_contacts [#freeagent_list_contacts] List contacts freeagent_create_contact [#freeagent_create_contact] Create contact freeagent_list_invoices [#freeagent_list_invoices] List invoices freeagent_create_invoice [#freeagent_create_invoice] Create invoice freeagent_list_bills [#freeagent_list_bills] List bills Notes [#notes] * Category: Accounting * Authentication mode: OAuth # Freshservice Integration The Freshservice integration provides access to manage Freshservice tickets, requesters, agents, assets, changes, problems, releases, and solutions through the Integrate MCP server. Installation [#installation] The Freshservice integration is included with the SDK: ```typescript import { freshserviceIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Freshservice OAuth App [#1-create-a-freshservice-oauth-app] 1. Create an OAuth application for Freshservice 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Freshservice integration to your server configuration. The integration automatically reads `FRESHSERVICE_CLIENT_ID` and `FRESHSERVICE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, freshserviceIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ freshserviceIntegration({ scopes: ["freshservice.tickets.read", "freshservice.tickets.write", "freshservice.assets.read", "freshservice.solutions.read"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript freshserviceIntegration({ clientId: process.env.CUSTOM_FRESHSERVICE_ID, clientSecret: process.env.CUSTOM_FRESHSERVICE_SECRET, scopes: ["freshservice.tickets.read", "freshservice.tickets.write", "freshservice.assets.read", "freshservice.solutions.read"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("freshservice"); const result = await client.freshservice.listTickets({ domain: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, freshserviceIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [freshserviceIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `freshservice.tickets.read` * `freshservice.tickets.write` * `freshservice.assets.read` * `freshservice.solutions.read` Tools [#tools] freshservice_list_tickets [#freshservice_list_tickets] List tickets freshservice_list_requesters [#freshservice_list_requesters] List requesters freshservice_list_agents [#freshservice_list_agents] List agents freshservice_list_assets [#freshservice_list_assets] List assets freshservice_list_changes [#freshservice_list_changes] List changes freshservice_list_problems [#freshservice_list_problems] List problems freshservice_list_releases [#freshservice_list_releases] List releases freshservice_create_ticket [#freshservice_create_ticket] Create ticket freshservice_list_solutions [#freshservice_list_solutions] List solutions Notes [#notes] * Category: Business * Authentication mode: OAuth # Garmin Integration The Garmin integration provides access to manage Garmin list activities, list daily summaries, list sleep, list heart rates, list body composition through the Integrate MCP server. Installation [#installation] The Garmin integration is included with the SDK: ```typescript import { garminIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Garmin OAuth App [#1-create-a-garmin-oauth-app] 1. Create an OAuth application for Garmin 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Garmin integration to your server configuration. The integration automatically reads `GARMIN_CLIENT_ID` and `GARMIN_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, garminIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ garminIntegration({ scopes: ["activities", "heartrate", "sleep", "stress", "body_composition", "user_metrics"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript garminIntegration({ clientId: process.env.CUSTOM_GARMIN_ID, clientSecret: process.env.CUSTOM_GARMIN_SECRET, scopes: ["activities", "heartrate", "sleep", "stress", "body_composition", "user_metrics"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("garmin"); const result = await client.garmin.listActivities({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, garminIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [garminIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `activities` * `heartrate` * `sleep` * `stress` * `body_composition` * `user_metrics` Tools [#tools] garmin_list_activities [#garmin_list_activities] List activities garmin_list_daily_summaries [#garmin_list_daily_summaries] List daily summaries garmin_list_sleep [#garmin_list_sleep] List sleep garmin_list_heart_rates [#garmin_list_heart_rates] List heart rates garmin_list_body_composition [#garmin_list_body_composition] List body composition Notes [#notes] * Category: Fitness * Authentication mode: OAuth # GitHub Integration The GitHub integration provides access to manage GitHub repos, issues, and pull requests through the Integrate MCP server. Installation [#installation] The GitHub integration is included with the SDK: ```typescript import { githubIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a GitHub OAuth App [#1-create-a-github-oauth-app] 1. Go to [GitHub Developer Settings](https://github.com/settings/developers) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the GitHub integration to your server configuration. The integration automatically reads `GITHUB_CLIENT_ID` and `GITHUB_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, githubIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript githubIntegration({ clientId: process.env.CUSTOM_GITHUB_ID, clientSecret: process.env.CUSTOM_GITHUB_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); const result = await client.github.createIssue({ owner: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, githubIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [githubIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] github_create_issue [#github_create_issue] Create a new issue in a repository github_list_issues [#github_list_issues] List issues in a repository github_get_issue [#github_get_issue] Get a specific issue github_update_issue [#github_update_issue] Update an existing issue github_close_issue [#github_close_issue] Close an issue github_create_pull_request [#github_create_pull_request] Create a pull request github_list_pull_requests [#github_list_pull_requests] List pull requests in a repository github_get_pull_request [#github_get_pull_request] Get a specific pull request github_merge_pull_request [#github_merge_pull_request] Merge a pull request github_list_repos [#github_list_repos] List repositories (for a user or organization) github_list_own_repos [#github_list_own_repos] List repositories for the authenticated user github_get_repo [#github_get_repo] Get a specific repository github_create_repo [#github_create_repo] Create a new repository github_list_branches [#github_list_branches] List branches in a repository github_create_branch [#github_create_branch] Create a new branch github_get_authenticated_user [#github_get_authenticated_user] Get information about the authenticated user *No parameters.* github_get_user [#github_get_user] Get information about a user github_list_commits [#github_list_commits] List commits in a repository github_get_commit [#github_get_commit] Get a specific commit github_list_issue_comments [#github_list_issue_comments] List comments on an issue github_add_issue_comment [#github_add_issue_comment] Add a comment to an issue github_update_issue_comment [#github_update_issue_comment] Update an issue comment github_delete_issue_comment [#github_delete_issue_comment] Delete an issue comment github_list_pr_files [#github_list_pr_files] List pr files *No parameters.* github_list_pr_commits [#github_list_pr_commits] List pr commits *No parameters.* github_list_pr_reviews [#github_list_pr_reviews] List pr reviews *No parameters.* github_create_pr_review [#github_create_pr_review] Create pr review *No parameters.* github_list_pr_review_comments [#github_list_pr_review_comments] List pr review comments *No parameters.* github_get_file_contents [#github_get_file_contents] Get the contents of a file or directory in a repository github_create_or_update_file [#github_create_or_update_file] Create or update a file in a repository github_delete_file [#github_delete_file] Delete a file from a repository github_list_releases [#github_list_releases] List releases in a repository github_get_release [#github_get_release] Get a specific release github_get_latest_release [#github_get_latest_release] Get the latest release for a repository github_create_release [#github_create_release] Create a release github_list_labels [#github_list_labels] List labels for a repository github_create_label [#github_create_label] Create a label in a repository github_add_issue_labels [#github_add_issue_labels] Add labels to an issue github_list_collaborators [#github_list_collaborators] List collaborators for a repository github_fork_repo [#github_fork_repo] Fork a repository github_search_repos [#github_search_repos] Search repositories github_search_issues [#github_search_issues] Search issues and pull requests github_search_code [#github_search_code] Search code github_list_workflows [#github_list_workflows] List workflows in a repository github_list_workflow_runs [#github_list_workflow_runs] List workflow runs for a repository or workflow github_trigger_workflow [#github_trigger_workflow] Trigger a workflow dispatch event github_list_milestones [#github_list_milestones] List milestones for a repository github_create_milestone [#github_create_milestone] Create a milestone Notes [#notes] * Category: Engineering * Authentication mode: OAuth # GitLab Integration The GitLab integration provides access to manage GitLab projects, issues, merge requests, and CI/CD through the Integrate MCP server. Installation [#installation] The GitLab integration is included with the SDK: ```typescript import { gitlabIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a GitLab OAuth App [#1-create-a-gitlab-oauth-app] 1. Create an OAuth application for GitLab 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the GitLab integration to your server configuration. The integration automatically reads `GITLAB_CLIENT_ID` and `GITLAB_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, gitlabIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ gitlabIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript gitlabIntegration({ clientId: process.env.CUSTOM_GITLAB_ID, clientSecret: process.env.CUSTOM_GITLAB_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("gitlab"); // Use client.gitlab methods after connecting ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, gitlabIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [gitlabIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] gitlab_list_projects [#gitlab_list_projects] List projects *No parameters.* gitlab_list_own_projects [#gitlab_list_own_projects] List own projects *No parameters.* gitlab_get_project [#gitlab_get_project] Get project *No parameters.* gitlab_create_project [#gitlab_create_project] Create project *No parameters.* gitlab_create_issue [#gitlab_create_issue] Create issue *No parameters.* gitlab_list_issues [#gitlab_list_issues] List issues *No parameters.* gitlab_get_issue [#gitlab_get_issue] Get issue *No parameters.* gitlab_update_issue [#gitlab_update_issue] Update issue *No parameters.* gitlab_close_issue [#gitlab_close_issue] Close issue *No parameters.* gitlab_create_merge_request [#gitlab_create_merge_request] Create merge request *No parameters.* gitlab_list_merge_requests [#gitlab_list_merge_requests] List merge requests *No parameters.* gitlab_get_merge_request [#gitlab_get_merge_request] Get merge request *No parameters.* gitlab_accept_merge_request [#gitlab_accept_merge_request] Accept merge request *No parameters.* gitlab_list_branches [#gitlab_list_branches] List branches *No parameters.* gitlab_create_branch [#gitlab_create_branch] Create branch *No parameters.* gitlab_list_commits [#gitlab_list_commits] List commits *No parameters.* gitlab_get_commit [#gitlab_get_commit] Get commit *No parameters.* gitlab_list_issue_notes [#gitlab_list_issue_notes] List issue notes *No parameters.* gitlab_create_issue_note [#gitlab_create_issue_note] Create issue note *No parameters.* gitlab_list_milestones [#gitlab_list_milestones] List milestones *No parameters.* gitlab_create_milestone [#gitlab_create_milestone] Create milestone *No parameters.* gitlab_get_current_user [#gitlab_get_current_user] Get current user *No parameters.* Notes [#notes] * Category: Engineering * Authentication mode: OAuth # Gmail Integration The Gmail integration provides access to send, read, and search Gmail messages through the Integrate MCP server. Installation [#installation] The Gmail integration is included with the SDK: ```typescript import { gmailIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Gmail OAuth App [#1-create-a-gmail-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Gmail integration to your server configuration. The integration automatically reads `GMAIL_CLIENT_ID` and `GMAIL_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, gmailIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ gmailIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript gmailIntegration({ clientId: process.env.CUSTOM_GMAIL_ID, clientSecret: process.env.CUSTOM_GMAIL_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("gmail"); const result = await client.gmail.sendMessage({ to: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, gmailIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [gmailIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] gmail_create_draft [#gmail_create_draft] Create a draft message gmail_get_attachment [#gmail_get_attachment] Get a message attachment payload gmail_get_message [#gmail_get_message] Get a specific message by ID gmail_get_thread [#gmail_get_thread] Get a specific thread by ID gmail_list_messages [#gmail_list_messages] List messages in the mailbox gmail_list_threads [#gmail_list_threads] List threads in the mailbox gmail_modify_message [#gmail_modify_message] Modify labels on a message gmail_reply_message [#gmail_reply_message] Reply to a message in a thread gmail_search_messages [#gmail_search_messages] Search messages with query gmail_send_message [#gmail_send_message] Send a message gmail_trash_message [#gmail_trash_message] Move a message to trash Notes [#notes] * Category: Communication * Authentication mode: OAuth # GoCardless Integration The GoCardless integration provides access to manage GoCardless institutions, requisitions, accounts, balances, and transactions through the Integrate MCP server. Installation [#installation] The GoCardless integration is included with the SDK: ```typescript import { gocardlessIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a GoCardless OAuth App [#1-create-a-gocardless-oauth-app] 1. Create an OAuth application for GoCardless 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the GoCardless integration to your server configuration. The integration automatically reads `GOCARDLESS_CLIENT_ID` and `GOCARDLESS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, gocardlessIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ gocardlessIntegration({ scopes: ["openid", "accounts", "transactions", "balances"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript gocardlessIntegration({ clientId: process.env.CUSTOM_GOCARDLESS_ID, clientSecret: process.env.CUSTOM_GOCARDLESS_SECRET, scopes: ["openid", "accounts", "transactions", "balances"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("gocardless"); const result = await client.gocardless.listInstitutions({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, gocardlessIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [gocardlessIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `openid` * `accounts` * `transactions` * `balances` Tools [#tools] gocardless_list_institutions [#gocardless_list_institutions] List institutions gocardless_create_requisition [#gocardless_create_requisition] Create requisition gocardless_get_requisition [#gocardless_get_requisition] Get requisition gocardless_get_account [#gocardless_get_account] Get account gocardless_get_balances [#gocardless_get_balances] Get balances gocardless_get_transactions [#gocardless_get_transactions] Get transactions Notes [#notes] * Category: Banking * Authentication mode: OAuth # Google Ads Integration The Google Ads integration provides access to manage Google Ads customers, campaigns, ad groups, ads, keywords, and conversions through the Integrate MCP server. Installation [#installation] The Google Ads integration is included with the SDK: ```typescript import { googleAdsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Ads OAuth App [#1-create-a-google-ads-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Ads integration to your server configuration. The integration automatically reads `GOOGLE_ADS_CLIENT_ID` and `GOOGLE_ADS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleAdsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleAdsIntegration({ scopes: ["https://www.googleapis.com/auth/adwords"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleAdsIntegration({ clientId: process.env.CUSTOM_GOOGLE_ADS_ID, clientSecret: process.env.CUSTOM_GOOGLE_ADS_SECRET, scopes: ["https://www.googleapis.com/auth/adwords"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_ads"); const result = await client.google_ads.listAccessibleCustomers({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleAdsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleAdsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `https://www.googleapis.com/auth/adwords` Tools [#tools] google_ads_list_accessible_customers [#google_ads_list_accessible_customers] Ads list accessible customers *No parameters.* google_ads_search [#google_ads_search] Ads search google_ads_list_campaigns [#google_ads_list_campaigns] Ads list campaigns google_ads_list_ad_groups [#google_ads_list_ad_groups] Ads list ad groups google_ads_list_ads [#google_ads_list_ads] Ads list ads google_ads_list_keywords [#google_ads_list_keywords] Ads list keywords google_ads_list_conversions [#google_ads_list_conversions] Ads list conversions Notes [#notes] * Category: Marketing * Authentication mode: OAuth # Google Analytics Integration The Google Analytics integration provides access to read Google Analytics reports, properties, and events through the Integrate MCP server. Installation [#installation] The Google Analytics integration is included with the SDK: ```typescript import { googleAnalyticsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Analytics OAuth App [#1-create-a-google-analytics-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Analytics integration to your server configuration. The integration automatically reads `GOOGLE_ANALYTICS_CLIENT_ID` and `GOOGLE_ANALYTICS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleAnalyticsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleAnalyticsIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleAnalyticsIntegration({ clientId: process.env.CUSTOM_GOOGLE_ANALYTICS_ID, clientSecret: process.env.CUSTOM_GOOGLE_ANALYTICS_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_analytics"); const result = await client.google_analytics.batchRunReports({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleAnalyticsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleAnalyticsIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] google_analytics_batch_run_reports [#google_analytics_batch_run_reports] Analytics batch run reports google_analytics_get_property [#google_analytics_get_property] Analytics get property google_analytics_list_account_summaries [#google_analytics_list_account_summaries] Analytics list account summaries google_analytics_run_realtime_report [#google_analytics_run_realtime_report] Analytics run realtime report google_analytics_run_report [#google_analytics_run_report] Analytics run report Notes [#notes] * Category: Analytics * Authentication mode: OAuth # Google Calendar Integration The Google Calendar integration provides access to manage Google Calendar events and schedules through the Integrate MCP server. Installation [#installation] The Google Calendar integration is included with the SDK: ```typescript import { googleCalendarIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Calendar OAuth App [#1-create-a-google-calendar-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Calendar integration to your server configuration. The integration automatically reads `GOOGLE_CALENDAR_CLIENT_ID` and `GOOGLE_CALENDAR_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleCalendarIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleCalendarIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleCalendarIntegration({ clientId: process.env.CUSTOM_GOOGLE_CALENDAR_ID, clientSecret: process.env.CUSTOM_GOOGLE_CALENDAR_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_calendar"); const result = await client.google_calendar.listCalendars({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleCalendarIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleCalendarIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] google_calendar_create_calendar [#google_calendar_create_calendar] Create a new calendar google_calendar_create_event [#google_calendar_create_event] Create a new event google_calendar_delete_calendar [#google_calendar_delete_calendar] Delete a calendar google_calendar_delete_event [#google_calendar_delete_event] Delete an event google_calendar_freebusy [#google_calendar_freebusy] Calendar freebusy google_calendar_get_calendar [#google_calendar_get_calendar] Get a specific calendar google_calendar_get_event [#google_calendar_get_event] Get a specific event google_calendar_list_attendees [#google_calendar_list_attendees] List attendees for an event google_calendar_list_calendars [#google_calendar_list_calendars] List calendars google_calendar_list_events [#google_calendar_list_events] List events in a calendar google_calendar_quick_add [#google_calendar_quick_add] Quickly add an event using natural language google_calendar_update_event [#google_calendar_update_event] Update an existing event Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Google Chat Integration The Google Chat integration provides access to list Google Chat spaces and manage messages and memberships through the Integrate MCP server. Installation [#installation] The Google Chat integration is included with the SDK: ```typescript import { googleChatIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Chat OAuth App [#1-create-a-google-chat-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Chat integration to your server configuration. The integration automatically reads `GOOGLE_CHAT_CLIENT_ID` and `GOOGLE_CHAT_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleChatIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleChatIntegration({ scopes: ["https://www.googleapis.com/auth/chat.messages", "https://www.googleapis.com/auth/chat.spaces.readonly"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleChatIntegration({ clientId: process.env.CUSTOM_GOOGLE_CHAT_ID, clientSecret: process.env.CUSTOM_GOOGLE_CHAT_SECRET, scopes: ["https://www.googleapis.com/auth/chat.messages", "https://www.googleapis.com/auth/chat.spaces.readonly"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_chat"); const result = await client.google_chat.deleteMessage({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleChatIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleChatIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `https://www.googleapis.com/auth/chat.messages` * `https://www.googleapis.com/auth/chat.spaces.readonly` Tools [#tools] google_chat_delete_message [#google_chat_delete_message] Chat delete message google_chat_get_message [#google_chat_get_message] Chat get message google_chat_get_space [#google_chat_get_space] Chat get space google_chat_list_members [#google_chat_list_members] Chat list members google_chat_list_messages [#google_chat_list_messages] Chat list messages google_chat_list_spaces [#google_chat_list_spaces] Chat list spaces google_chat_send_message [#google_chat_send_message] Chat send message google_chat_update_message [#google_chat_update_message] Chat update message Notes [#notes] * Category: Communication * Authentication mode: OAuth # Google Classroom Integration The Google Classroom integration provides access to manage Google Classroom list courses, get course, create course, list coursework, create coursework through the Integrate MCP server. Installation [#installation] The Google Classroom integration is included with the SDK: ```typescript import { googleClassroomIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Classroom OAuth App [#1-create-a-google-classroom-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Classroom integration to your server configuration. The integration automatically reads `GOOGLE_CLASSROOM_CLIENT_ID` and `GOOGLE_CLASSROOM_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleClassroomIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleClassroomIntegration({ scopes: ["https://www.googleapis.com/auth/classroom.courses", "https://www.googleapis.com/auth/classroom.coursework.me", "https://www.googleapis.com/auth/classroom.rosters", "https://www.googleapis.com/auth/classroom.profile.emails"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleClassroomIntegration({ clientId: process.env.CUSTOM_GOOGLE_CLASSROOM_ID, clientSecret: process.env.CUSTOM_GOOGLE_CLASSROOM_SECRET, scopes: ["https://www.googleapis.com/auth/classroom.courses", "https://www.googleapis.com/auth/classroom.coursework.me", "https://www.googleapis.com/auth/classroom.rosters", "https://www.googleapis.com/auth/classroom.profile.emails"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_classroom"); const result = await client.google_classroom.listCourses({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleClassroomIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleClassroomIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `https://www.googleapis.com/auth/classroom.courses` * `https://www.googleapis.com/auth/classroom.coursework.me` * `https://www.googleapis.com/auth/classroom.rosters` * `https://www.googleapis.com/auth/classroom.profile.emails` Tools [#tools] google_classroom_list_courses [#google_classroom_list_courses] Classroom list courses google_classroom_get_course [#google_classroom_get_course] Classroom get course google_classroom_create_course [#google_classroom_create_course] Classroom create course google_classroom_list_coursework [#google_classroom_list_coursework] Classroom list coursework google_classroom_create_coursework [#google_classroom_create_coursework] Classroom create coursework google_classroom_list_students [#google_classroom_list_students] Classroom list students Notes [#notes] * Category: Education * Authentication mode: OAuth # Google Contacts Integration The Google Contacts integration provides access to list, search, create, update, and delete Google Contacts via the People API through the Integrate MCP server. Installation [#installation] The Google Contacts integration is included with the SDK: ```typescript import { googleContactsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Contacts OAuth App [#1-create-a-google-contacts-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Contacts integration to your server configuration. The integration automatically reads `GOOGLE_CONTACTS_CLIENT_ID` and `GOOGLE_CONTACTS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleContactsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleContactsIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleContactsIntegration({ clientId: process.env.CUSTOM_GOOGLE_CONTACTS_ID, clientSecret: process.env.CUSTOM_GOOGLE_CONTACTS_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_contacts"); const result = await client.google_contacts.batchGetContacts({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleContactsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleContactsIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] google_contacts_batch_get_contacts [#google_contacts_batch_get_contacts] Contacts batch get contacts google_contacts_copy_other_contact [#google_contacts_copy_other_contact] Contacts copy other contact google_contacts_create_contact [#google_contacts_create_contact] Contacts create contact google_contacts_delete_contact [#google_contacts_delete_contact] Contacts delete contact google_contacts_get_person [#google_contacts_get_person] Contacts get person google_contacts_get_self [#google_contacts_get_self] Contacts get self google_contacts_list_connections [#google_contacts_list_connections] Contacts list connections google_contacts_list_other_contacts [#google_contacts_list_other_contacts] Contacts list other contacts google_contacts_search_contacts [#google_contacts_search_contacts] Contacts search contacts google_contacts_update_contact [#google_contacts_update_contact] Contacts update contact Notes [#notes] * Category: Communication * Authentication mode: OAuth # Google Docs Integration The Google Docs integration provides access to create and edit Google Docs documents through the Integrate MCP server. Installation [#installation] The Google Docs integration is included with the SDK: ```typescript import { googleDocsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Docs OAuth App [#1-create-a-google-docs-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Docs integration to your server configuration. The integration automatically reads `GOOGLE_DOCS_CLIENT_ID` and `GOOGLE_DOCS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleDocsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleDocsIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleDocsIntegration({ clientId: process.env.CUSTOM_GOOGLE_DOCS_ID, clientSecret: process.env.CUSTOM_GOOGLE_DOCS_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_docs"); const result = await client.google_docs.list({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleDocsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleDocsIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] google_docs_append_text [#google_docs_append_text] Docs append text google_docs_batch_update [#google_docs_batch_update] Docs batch update google_docs_create [#google_docs_create] Docs create google_docs_create_comment [#google_docs_create_comment] Docs create comment google_docs_delete [#google_docs_delete] Docs delete google_docs_delete_comment [#google_docs_delete_comment] Docs delete comment google_docs_get [#google_docs_get] Docs get google_docs_list [#google_docs_list] Docs list google_docs_list_comments [#google_docs_list_comments] Docs list comments google_docs_replace_text [#google_docs_replace_text] Docs replace text Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Google Drive Integration The Google Drive integration provides access to manage Google Drive files, folders, and sharing through the Integrate MCP server. Installation [#installation] The Google Drive integration is included with the SDK: ```typescript import { googleDriveIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Drive OAuth App [#1-create-a-google-drive-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Drive integration to your server configuration. The integration automatically reads `GOOGLE_DRIVE_CLIENT_ID` and `GOOGLE_DRIVE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleDriveIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleDriveIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleDriveIntegration({ clientId: process.env.CUSTOM_GOOGLE_DRIVE_ID, clientSecret: process.env.CUSTOM_GOOGLE_DRIVE_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_drive"); const result = await client.google_drive.listFiles({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleDriveIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleDriveIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] google_drive_copy_file [#google_drive_copy_file] Copy a file google_drive_create_folder [#google_drive_create_folder] Create a new folder google_drive_delete_file [#google_drive_delete_file] Permanently delete a file or folder (not recoverable) google_drive_download_file [#google_drive_download_file] Download file content as text. Google Workspace files are auto-exported. google_drive_get_about [#google_drive_get_about] Get current user info and storage quota *No parameters.* google_drive_get_file [#google_drive_get_file] Get metadata for a file or folder google_drive_list_files [#google_drive_list_files] List files and folders in Google Drive google_drive_list_permissions [#google_drive_list_permissions] List sharing permissions on a file or folder google_drive_move_file [#google_drive_move_file] Move a file or folder to a different parent google_drive_remove_permission [#google_drive_remove_permission] Remove a sharing permission google_drive_rename_file [#google_drive_rename_file] Rename a file or folder google_drive_share_file [#google_drive_share_file] Share a file or folder google_drive_trash_file [#google_drive_trash_file] Move a file or folder to trash (recoverable) google_drive_upload_text_file [#google_drive_upload_text_file] Create a new file with text content Notes [#notes] * Category: Storage * Authentication mode: OAuth # Google Forms Integration The Google Forms integration provides access to manage Google Forms forms, structure updates, and responses through the Integrate MCP server. Installation [#installation] The Google Forms integration is included with the SDK: ```typescript import { googleFormsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Forms OAuth App [#1-create-a-google-forms-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Forms integration to your server configuration. The integration automatically reads `GOOGLE_FORMS_CLIENT_ID` and `GOOGLE_FORMS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleFormsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleFormsIntegration({ scopes: ["openid", "email", "https://www.googleapis.com/auth/forms.body", "https://www.googleapis.com/auth/forms.responses.readonly", "https://www.googleapis.com/auth/drive.readonly"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleFormsIntegration({ clientId: process.env.CUSTOM_GOOGLE_FORMS_ID, clientSecret: process.env.CUSTOM_GOOGLE_FORMS_SECRET, scopes: ["openid", "email", "https://www.googleapis.com/auth/forms.body", "https://www.googleapis.com/auth/forms.responses.readonly", "https://www.googleapis.com/auth/drive.readonly"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_forms"); const result = await client.google_forms.createForm({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleFormsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleFormsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `openid` * `email` * `https://www.googleapis.com/auth/forms.body` * `https://www.googleapis.com/auth/forms.responses.readonly` * `https://www.googleapis.com/auth/drive.readonly` Tools [#tools] google_forms_create_form [#google_forms_create_form] Forms create form google_forms_get_form [#google_forms_get_form] Forms get form google_forms_batch_update_form [#google_forms_batch_update_form] Forms batch update form google_forms_list_form_responses [#google_forms_list_form_responses] Forms list form responses google_forms_get_form_response [#google_forms_get_form_response] Forms get form response Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Google Home Integration The Google Home integration provides access to manage Google Home devices, structures, rooms, and device commands through the Integrate MCP server. Installation [#installation] The Google Home integration is included with the SDK: ```typescript import { googleHomeIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Home OAuth App [#1-create-a-google-home-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Home integration to your server configuration. The integration automatically reads `GOOGLE_HOME_CLIENT_ID` and `GOOGLE_HOME_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleHomeIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleHomeIntegration({ scopes: ["https://www.googleapis.com/auth/sdm.service"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleHomeIntegration({ clientId: process.env.CUSTOM_GOOGLE_HOME_ID, clientSecret: process.env.CUSTOM_GOOGLE_HOME_SECRET, scopes: ["https://www.googleapis.com/auth/sdm.service"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_home"); const result = await client.google_home.listDevices({ project_id: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleHomeIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleHomeIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `https://www.googleapis.com/auth/sdm.service` Tools [#tools] google_home_list_devices [#google_home_list_devices] Home list devices google_home_get_device [#google_home_get_device] Home get device google_home_execute_device_command [#google_home_execute_device_command] Home execute device command google_home_list_structures [#google_home_list_structures] Home list structures google_home_list_rooms [#google_home_list_rooms] Home list rooms Notes [#notes] * Category: Lifestyle * Authentication mode: OAuth # Google Keep Integration The Google Keep integration provides access to manage Google Keep notes, attachments, and sharing permissions through the Integrate MCP server. Installation [#installation] The Google Keep integration is included with the SDK: ```typescript import { googleKeepIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Keep OAuth App [#1-create-a-google-keep-oauth-app] 1. Create an OAuth application for Google Keep 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Keep integration to your server configuration. The integration automatically reads `GOOGLE_KEEP_CLIENT_ID` and `GOOGLE_KEEP_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleKeepIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleKeepIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleKeepIntegration({ clientId: process.env.CUSTOM_GOOGLE_KEEP_ID, clientSecret: process.env.CUSTOM_GOOGLE_KEEP_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_keep"); const result = await client.google_keep.listNotes({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleKeepIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleKeepIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] google_keep_list_notes [#google_keep_list_notes] Keep list notes google_keep_get_note [#google_keep_get_note] Keep get note google_keep_create_text_note [#google_keep_create_text_note] Keep create text note google_keep_create_list_note [#google_keep_create_list_note] Keep create list note google_keep_delete_note [#google_keep_delete_note] Keep delete note google_keep_download_attachment [#google_keep_download_attachment] Keep download attachment google_keep_batch_create_permissions [#google_keep_batch_create_permissions] Keep batch create permissions google_keep_batch_delete_permissions [#google_keep_batch_delete_permissions] Keep batch delete permissions Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Google Meet Integration The Google Meet integration provides access to create and manage Google Meet links via Calendar conference data through the Integrate MCP server. Installation [#installation] The Google Meet integration is included with the SDK: ```typescript import { googleMeetIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Meet OAuth App [#1-create-a-google-meet-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Meet integration to your server configuration. The integration automatically reads `GOOGLE_MEET_CLIENT_ID` and `GOOGLE_MEET_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleMeetIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleMeetIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleMeetIntegration({ clientId: process.env.CUSTOM_GOOGLE_MEET_ID, clientSecret: process.env.CUSTOM_GOOGLE_MEET_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_meet"); const result = await client.google_meet.addMeetToEvent({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleMeetIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleMeetIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] google_meet_add_meet_to_event [#google_meet_add_meet_to_event] Meet add meet to event google_meet_create_meeting [#google_meet_create_meeting] Meet create meeting google_meet_delete_meeting [#google_meet_delete_meeting] Meet delete meeting google_meet_get_meeting [#google_meet_get_meeting] Meet get meeting google_meet_list_meetings [#google_meet_list_meetings] Meet list meetings google_meet_update_meeting [#google_meet_update_meeting] Meet update meeting Notes [#notes] * Category: Communication * Authentication mode: OAuth # Google Play Console Integration The Google Play Console integration provides access to manage Google Play edits, tracks, and in-app products through the Android Publisher API through the Integrate MCP server. Installation [#installation] The Google Play Console integration is included with the SDK: ```typescript import { googlePlayConsoleIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Play Console OAuth App [#1-create-a-google-play-console-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Play Console integration to your server configuration. The integration automatically reads `GOOGLE_PLAY_CONSOLE_CLIENT_ID` and `GOOGLE_PLAY_CONSOLE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googlePlayConsoleIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googlePlayConsoleIntegration({ scopes: ["openid", "email", "https://www.googleapis.com/auth/androidpublisher"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googlePlayConsoleIntegration({ clientId: process.env.CUSTOM_GOOGLE_PLAY_CONSOLE_ID, clientSecret: process.env.CUSTOM_GOOGLE_PLAY_CONSOLE_SECRET, scopes: ["openid", "email", "https://www.googleapis.com/auth/androidpublisher"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_play_console"); const result = await client.google_play_console.insertEdit({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googlePlayConsoleIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googlePlayConsoleIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `openid` * `email` * `https://www.googleapis.com/auth/androidpublisher` Tools [#tools] google_play_console_insert_edit [#google_play_console_insert_edit] Play console insert edit google_play_console_get_edit [#google_play_console_get_edit] Play console get edit google_play_console_list_tracks [#google_play_console_list_tracks] Play console list tracks google_play_console_update_track [#google_play_console_update_track] Play console update track google_play_console_commit_edit [#google_play_console_commit_edit] Play console commit edit google_play_console_list_in_app_products [#google_play_console_list_in_app_products] Play console list in app products Notes [#notes] * Category: Engineering * Authentication mode: OAuth # Google Sheets Integration The Google Sheets integration provides access to read and update Google Sheets spreadsheets through the Integrate MCP server. Installation [#installation] The Google Sheets integration is included with the SDK: ```typescript import { googleSheetsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Sheets OAuth App [#1-create-a-google-sheets-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Sheets integration to your server configuration. The integration automatically reads `GOOGLE_SHEETS_CLIENT_ID` and `GOOGLE_SHEETS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleSheetsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleSheetsIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleSheetsIntegration({ clientId: process.env.CUSTOM_GOOGLE_SHEETS_ID, clientSecret: process.env.CUSTOM_GOOGLE_SHEETS_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_sheets"); const result = await client.google_sheets.list({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleSheetsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleSheetsIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] google_sheets_append_values [#google_sheets_append_values] Sheets append values google_sheets_batch_update [#google_sheets_batch_update] Sheets batch update google_sheets_batch_update_values [#google_sheets_batch_update_values] Sheets batch update values google_sheets_clear_values [#google_sheets_clear_values] Sheets clear values google_sheets_create [#google_sheets_create] Sheets create google_sheets_delete [#google_sheets_delete] Sheets delete google_sheets_get [#google_sheets_get] Sheets get google_sheets_get_values [#google_sheets_get_values] Sheets get values google_sheets_list [#google_sheets_list] Sheets list google_sheets_update_values [#google_sheets_update_values] Sheets update values Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Google Slides Integration The Google Slides integration provides access to create and update Google Slides presentations through the Integrate MCP server. Installation [#installation] The Google Slides integration is included with the SDK: ```typescript import { googleSlidesIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Slides OAuth App [#1-create-a-google-slides-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Slides integration to your server configuration. The integration automatically reads `GOOGLE_SLIDES_CLIENT_ID` and `GOOGLE_SLIDES_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleSlidesIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleSlidesIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleSlidesIntegration({ clientId: process.env.CUSTOM_GOOGLE_SLIDES_ID, clientSecret: process.env.CUSTOM_GOOGLE_SLIDES_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_slides"); const result = await client.google_slides.list({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleSlidesIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleSlidesIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] google_slides_add_slide [#google_slides_add_slide] Slides add slide google_slides_batch_update [#google_slides_batch_update] Slides batch update google_slides_create [#google_slides_create] Slides create google_slides_delete [#google_slides_delete] Slides delete google_slides_delete_slide [#google_slides_delete_slide] Slides delete slide google_slides_get [#google_slides_get] Slides get google_slides_get_page [#google_slides_get_page] Slides get page google_slides_list [#google_slides_list] Slides list google_slides_update_text [#google_slides_update_text] Slides update text Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Google Tasks Integration The Google Tasks integration provides access to manage Google Tasks lists and to-dos synced with your Google account through the Integrate MCP server. Installation [#installation] The Google Tasks integration is included with the SDK: ```typescript import { googleTasksIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Google Tasks OAuth App [#1-create-a-google-tasks-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Google Tasks integration to your server configuration. The integration automatically reads `GOOGLE_TASKS_CLIENT_ID` and `GOOGLE_TASKS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, googleTasksIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ googleTasksIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript googleTasksIntegration({ clientId: process.env.CUSTOM_GOOGLE_TASKS_ID, clientSecret: process.env.CUSTOM_GOOGLE_TASKS_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("google_tasks"); const result = await client.google_tasks.clearCompleted({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, googleTasksIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [googleTasksIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] google_tasks_clear_completed [#google_tasks_clear_completed] Tasks clear completed google_tasks_create_task [#google_tasks_create_task] Tasks create task google_tasks_create_tasklist [#google_tasks_create_tasklist] Tasks create tasklist google_tasks_delete_task [#google_tasks_delete_task] Tasks delete task google_tasks_delete_tasklist [#google_tasks_delete_tasklist] Tasks delete tasklist google_tasks_get_task [#google_tasks_get_task] Tasks get task google_tasks_get_tasklist [#google_tasks_get_tasklist] Tasks get tasklist google_tasks_list_tasklists [#google_tasks_list_tasklists] Tasks list tasklists google_tasks_list_tasks [#google_tasks_list_tasks] Tasks list tasks google_tasks_move_task [#google_tasks_move_task] Tasks move task google_tasks_update_task [#google_tasks_update_task] Tasks update task google_tasks_update_tasklist [#google_tasks_update_tasklist] Tasks update tasklist Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Granola Integration The Granola integration provides access to list and read Granola meeting notes and folders through the Integrate MCP server. Installation [#installation] The Granola integration is included with the SDK: ```typescript import { granolaIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Granola to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, granolaIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ granolaIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; // Use client.granola methods after connecting ``` Environment Variables [#environment-variables] * `GRANOLA_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] granola_list_notes [#granola_list_notes] List notes *No parameters.* granola_get_note [#granola_get_note] Get note *No parameters.* granola_list_folders [#granola_list_folders] List folders *No parameters.* Notes [#notes] * Category: Productivity * Authentication mode: API key # Greenhouse Integration The Greenhouse integration provides access to manage Greenhouse list candidates, get candidate, create candidate, list jobs, list applications through the Integrate MCP server. Installation [#installation] The Greenhouse integration is included with the SDK: ```typescript import { greenhouseIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Greenhouse OAuth App [#1-create-a-greenhouse-oauth-app] 1. Create an OAuth application for Greenhouse 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Greenhouse integration to your server configuration. The integration automatically reads `GREENHOUSE_CLIENT_ID` and `GREENHOUSE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, greenhouseIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ greenhouseIntegration({ scopes: ["candidates:read", "candidates:write", "jobs:read", "applications:read", "users:read"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript greenhouseIntegration({ clientId: process.env.CUSTOM_GREENHOUSE_ID, clientSecret: process.env.CUSTOM_GREENHOUSE_SECRET, scopes: ["candidates:read", "candidates:write", "jobs:read", "applications:read", "users:read"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("greenhouse"); const result = await client.greenhouse.listCandidates({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, greenhouseIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [greenhouseIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `candidates:read` * `candidates:write` * `jobs:read` * `applications:read` * `users:read` Tools [#tools] greenhouse_list_candidates [#greenhouse_list_candidates] List candidates greenhouse_get_candidate [#greenhouse_get_candidate] Get candidate greenhouse_create_candidate [#greenhouse_create_candidate] Create candidate greenhouse_list_jobs [#greenhouse_list_jobs] List jobs greenhouse_list_applications [#greenhouse_list_applications] List applications greenhouse_list_users [#greenhouse_list_users] List users Notes [#notes] * Category: HR & Recruiting * Authentication mode: OAuth # Home Connect Integration The Home Connect integration provides access to manage Home Connect list appliances, get appliance, get status, get programs, start program through the Integrate MCP server. Installation [#installation] The Home Connect integration is included with the SDK: ```typescript import { homeConnectIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Home Connect OAuth App [#1-create-a-home-connect-oauth-app] 1. Create an OAuth application for Home Connect 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Home Connect integration to your server configuration. The integration automatically reads `HOME_CONNECT_CLIENT_ID` and `HOME_CONNECT_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, homeConnectIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ homeConnectIntegration({ scopes: ["IdentifyAppliance", "Monitor", "Settings", "Control"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript homeConnectIntegration({ clientId: process.env.CUSTOM_HOME_CONNECT_ID, clientSecret: process.env.CUSTOM_HOME_CONNECT_SECRET, scopes: ["IdentifyAppliance", "Monitor", "Settings", "Control"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("home_connect"); const result = await client.home_connect.listAppliances({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, homeConnectIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [homeConnectIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `IdentifyAppliance` * `Monitor` * `Settings` * `Control` Tools [#tools] home_connect_list_appliances [#home_connect_list_appliances] Connect list appliances *No parameters.* home_connect_get_appliance [#home_connect_get_appliance] Connect get appliance home_connect_get_status [#home_connect_get_status] Connect get status home_connect_get_programs [#home_connect_get_programs] Connect get programs home_connect_start_program [#home_connect_start_program] Connect start program home_connect_set_setting [#home_connect_set_setting] Connect set setting Notes [#notes] * Category: Lifestyle * Authentication mode: OAuth # HubSpot Integration The HubSpot integration provides access to manage HubSpot contacts, deals, and tickets through the Integrate MCP server. Installation [#installation] The HubSpot integration is included with the SDK: ```typescript import { hubspotIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a HubSpot OAuth App [#1-create-a-hubspot-oauth-app] 1. Go to [HubSpot Developer Apps](https://app.hubspot.com/developers) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the HubSpot integration to your server configuration. The integration automatically reads `HUBSPOT_CLIENT_ID` and `HUBSPOT_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, hubspotIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ hubspotIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript hubspotIntegration({ clientId: process.env.CUSTOM_HUBSPOT_ID, clientSecret: process.env.CUSTOM_HUBSPOT_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("hubspot"); const result = await client.hubspot.listContacts({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, hubspotIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [hubspotIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] hubspot_list_contacts [#hubspot_list_contacts] List contacts hubspot_get_contact [#hubspot_get_contact] Get contact hubspot_create_contact [#hubspot_create_contact] Create contact hubspot_update_contact [#hubspot_update_contact] Update contact hubspot_delete_contact [#hubspot_delete_contact] Delete contact hubspot_list_companies [#hubspot_list_companies] List companies hubspot_get_company [#hubspot_get_company] Get company hubspot_create_company [#hubspot_create_company] Create company hubspot_update_company [#hubspot_update_company] Update company hubspot_delete_company [#hubspot_delete_company] Delete company hubspot_list_deals [#hubspot_list_deals] List deals hubspot_get_deal [#hubspot_get_deal] Get deal hubspot_create_deal [#hubspot_create_deal] Create deal hubspot_update_deal [#hubspot_update_deal] Update deal hubspot_delete_deal [#hubspot_delete_deal] Delete deal hubspot_list_tickets [#hubspot_list_tickets] List tickets hubspot_get_ticket [#hubspot_get_ticket] Get ticket hubspot_create_ticket [#hubspot_create_ticket] Create ticket hubspot_update_ticket [#hubspot_update_ticket] Update ticket hubspot_delete_ticket [#hubspot_delete_ticket] Delete ticket hubspot_search_crm [#hubspot_search_crm] Search crm hubspot_create_note [#hubspot_create_note] Create note hubspot_create_task [#hubspot_create_task] Create task hubspot_list_owners [#hubspot_list_owners] List owners hubspot_get_owner [#hubspot_get_owner] Get owner hubspot_list_pipelines [#hubspot_list_pipelines] List pipelines hubspot_list_pipeline_stages [#hubspot_list_pipeline_stages] List pipeline stages hubspot_create_association [#hubspot_create_association] Create association Notes [#notes] * Category: Business * Authentication mode: OAuth # Integrations import { Cards, Card } from "fumadocs-ui/components/card"; The Integrate MCP server exposes tools for 200+ third-party services. Each integration has its own OAuth configuration, scopes, and typed tools in the SDK. Browse the sidebar for a specific provider, or start with the most common ones below. Full catalog [#full-catalog] See the [integrations directory](/integrations) on the marketing site for logos and search, or use the docs sidebar for per-integration setup guides. Custom integrations [#custom-integrations] New providers are added on the [Integrate MCP server](https://github.com/integratedotdev/mcp-server). If you need a provider that is not listed yet, open an issue or contribute an integration following the patterns in that repository. # Instagram Integration The Instagram integration provides access to instagram Graph API for professional accounts β€” pages, media, comments, insights, stories, and publishing. through the Integrate MCP server. Installation [#installation] The Instagram integration is included with the SDK: ```typescript import { instagramIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Instagram OAuth App [#1-create-an-instagram-oauth-app] 1. Go to [Facebook Developer Portal](https://www.facebook.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Instagram integration to your server configuration. The integration automatically reads `INSTAGRAM_CLIENT_ID` and `INSTAGRAM_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, instagramIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ instagramIntegration({ scopes: ["pages_show_list", "pages_read_engagement", "instagram_basic", "instagram_manage_insights", "instagram_manage_comments", "instagram_content_publish"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript instagramIntegration({ clientId: process.env.CUSTOM_INSTAGRAM_ID, clientSecret: process.env.CUSTOM_INSTAGRAM_SECRET, scopes: ["pages_show_list", "pages_read_engagement", "instagram_basic", "instagram_manage_insights", "instagram_manage_comments", "instagram_content_publish"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("instagram"); const result = await client.instagram.listPages({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, instagramIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [instagramIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `pages_show_list` * `pages_read_engagement` * `instagram_basic` * `instagram_manage_insights` * `instagram_manage_comments` * `instagram_content_publish` Tools [#tools] instagram_list_pages [#instagram_list_pages] List pages instagram_get_profile [#instagram_get_profile] Get profile instagram_list_media [#instagram_list_media] List media instagram_get_media [#instagram_get_media] Get media instagram_list_comments [#instagram_list_comments] List comments instagram_reply_comment [#instagram_reply_comment] Reply comment instagram_delete_comment [#instagram_delete_comment] Delete comment instagram_hide_comment [#instagram_hide_comment] Hide comment instagram_get_media_insights [#instagram_get_media_insights] Get media insights instagram_get_user_insights [#instagram_get_user_insights] Get user insights instagram_create_media_container [#instagram_create_media_container] Create media container instagram_publish_media [#instagram_publish_media] Publish media instagram_list_stories [#instagram_list_stories] List stories instagram_list_tagged_media [#instagram_list_tagged_media] List tagged media Notes [#notes] * Category: Social Media * Authentication mode: OAuth # Intercom Integration The Intercom integration provides access to manage Intercom contacts and conversations through the Integrate MCP server. Installation [#installation] The Intercom integration is included with the SDK: ```typescript import { intercomIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Intercom OAuth App [#1-create-an-intercom-oauth-app] 1. Go to [Intercom Developer Hub](https://developers.intercom.com/) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Intercom integration to your server configuration. The integration automatically reads `INTERCOM_CLIENT_ID` and `INTERCOM_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, intercomIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ intercomIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript intercomIntegration({ clientId: process.env.CUSTOM_INTERCOM_ID, clientSecret: process.env.CUSTOM_INTERCOM_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("intercom"); const result = await client.intercom.listContacts({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, intercomIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [intercomIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] intercom_list_contacts [#intercom_list_contacts] List contacts intercom_get_contact [#intercom_get_contact] Get contact details intercom_create_contact [#intercom_create_contact] Create a new contact intercom_list_conversations [#intercom_list_conversations] List conversations intercom_get_conversation [#intercom_get_conversation] Get conversation details intercom_reply_conversation [#intercom_reply_conversation] Reply to a conversation intercom_list_companies [#intercom_list_companies] List companies intercom_get_company [#intercom_get_company] Get company details intercom_search_contacts [#intercom_search_contacts] Search for contacts Notes [#notes] * Category: Business * Authentication mode: OAuth # Jira Integration The Jira integration provides access to manage Jira issues, projects, sprints, and boards through the Integrate MCP server. Installation [#installation] The Jira integration is included with the SDK: ```typescript import { jiraIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Jira OAuth App [#1-create-a-jira-oauth-app] 1. Go to [Auth Developer Portal](https://auth.atlassian.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Jira integration to your server configuration. The integration automatically reads `JIRA_CLIENT_ID` and `JIRA_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, jiraIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ jiraIntegration({ scopes: ["read:jira-work", "write:jira-work", "read:account", "offline_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript jiraIntegration({ clientId: process.env.CUSTOM_JIRA_ID, clientSecret: process.env.CUSTOM_JIRA_SECRET, scopes: ["read:jira-work", "write:jira-work", "read:account", "offline_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("jira"); const result = await client.jira.listProjects({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, jiraIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [jiraIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `read:jira-work` * `write:jira-work` * `read:account` * `offline_access` Tools [#tools] jira_list_projects [#jira_list_projects] List projects jira_get_project [#jira_get_project] Get project jira_get_issue_types [#jira_get_issue_types] Get issue types jira_search_issues [#jira_search_issues] Search issues jira_get_issue [#jira_get_issue] Get issue jira_create_issue [#jira_create_issue] Create issue jira_update_issue [#jira_update_issue] Update issue jira_get_transitions [#jira_get_transitions] Get transitions jira_transition_issue [#jira_transition_issue] Transition issue jira_add_comment [#jira_add_comment] Add comment jira_assign_issue [#jira_assign_issue] Assign issue jira_list_boards [#jira_list_boards] List boards jira_list_sprints [#jira_list_sprints] List sprints Notes [#notes] * Category: Engineering * Authentication mode: OAuth # Kick Integration The Kick integration provides access to manage Kick get users, get channels, get livestreams, get categories, send chat message through the Integrate MCP server. Installation [#installation] The Kick integration is included with the SDK: ```typescript import { kickIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Kick OAuth App [#1-create-a-kick-oauth-app] 1. Create an OAuth application for Kick 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Kick integration to your server configuration. The integration automatically reads `KICK_CLIENT_ID` and `KICK_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, kickIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ kickIntegration({ scopes: ["user:read", "channel:read", "channel:write", "chat:write", "events:subscribe"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript kickIntegration({ clientId: process.env.CUSTOM_KICK_ID, clientSecret: process.env.CUSTOM_KICK_SECRET, scopes: ["user:read", "channel:read", "channel:write", "chat:write", "events:subscribe"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("kick"); const result = await client.kick.getUsers({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, kickIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [kickIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `user:read` * `channel:read` * `channel:write` * `chat:write` * `events:subscribe` Tools [#tools] kick_get_users [#kick_get_users] Get users kick_get_channels [#kick_get_channels] Get channels kick_get_livestreams [#kick_get_livestreams] Get livestreams kick_get_categories [#kick_get_categories] Get categories kick_send_chat_message [#kick_send_chat_message] Send chat message Notes [#notes] * Category: Entertainment * Authentication mode: OAuth # Klaviyo Integration The Klaviyo integration provides access to manage Klaviyo accounts, profiles, lists, segments, campaigns, and metrics through the Integrate MCP server. Installation [#installation] The Klaviyo integration is included with the SDK: ```typescript import { klaviyoIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Klaviyo OAuth App [#1-create-a-klaviyo-oauth-app] 1. Create an OAuth application for Klaviyo 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Klaviyo integration to your server configuration. The integration automatically reads `KLAVIYO_CLIENT_ID` and `KLAVIYO_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, klaviyoIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ klaviyoIntegration({ scopes: ["accounts:read", "profiles:read", "profiles:write", "lists:read", "lists:write", "campaigns:read", "campaigns:write", "metrics:read"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript klaviyoIntegration({ clientId: process.env.CUSTOM_KLAVIYO_ID, clientSecret: process.env.CUSTOM_KLAVIYO_SECRET, scopes: ["accounts:read", "profiles:read", "profiles:write", "lists:read", "lists:write", "campaigns:read", "campaigns:write", "metrics:read"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("klaviyo"); const result = await client.klaviyo.listAccounts({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, klaviyoIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [klaviyoIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `accounts:read` * `profiles:read` * `profiles:write` * `lists:read` * `lists:write` * `campaigns:read` * `campaigns:write` * `metrics:read` Tools [#tools] klaviyo_list_accounts [#klaviyo_list_accounts] List accounts klaviyo_list_profiles [#klaviyo_list_profiles] List profiles klaviyo_get_profile [#klaviyo_get_profile] Get profile klaviyo_create_profile [#klaviyo_create_profile] Create profile klaviyo_list_lists [#klaviyo_list_lists] List lists klaviyo_list_campaigns [#klaviyo_list_campaigns] List campaigns klaviyo_create_campaign [#klaviyo_create_campaign] Create campaign klaviyo_list_metrics [#klaviyo_list_metrics] List metrics Notes [#notes] * Category: Marketing * Authentication mode: OAuth # Lever Integration The Lever integration provides access to manage Lever list opportunities, get opportunity, create opportunity, list postings, list users through the Integrate MCP server. Installation [#installation] The Lever integration is included with the SDK: ```typescript import { leverIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Lever OAuth App [#1-create-a-lever-oauth-app] 1. Create an OAuth application for Lever 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Lever integration to your server configuration. The integration automatically reads `LEVER_CLIENT_ID` and `LEVER_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, leverIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ leverIntegration({ scopes: ["opportunities:read", "opportunities:write", "postings:read", "postings:write", "users:read", "offline_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript leverIntegration({ clientId: process.env.CUSTOM_LEVER_ID, clientSecret: process.env.CUSTOM_LEVER_SECRET, scopes: ["opportunities:read", "opportunities:write", "postings:read", "postings:write", "users:read", "offline_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("lever"); const result = await client.lever.listOpportunities({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, leverIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [leverIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `opportunities:read` * `opportunities:write` * `postings:read` * `postings:write` * `users:read` * `offline_access` Tools [#tools] lever_list_opportunities [#lever_list_opportunities] List opportunities lever_get_opportunity [#lever_get_opportunity] Get opportunity lever_create_opportunity [#lever_create_opportunity] Create opportunity lever_list_postings [#lever_list_postings] List postings lever_list_users [#lever_list_users] List users lever_list_stages [#lever_list_stages] List stages *No parameters.* Notes [#notes] * Category: HR & Recruiting * Authentication mode: OAuth # Linear Integration The Linear integration provides access to manage Linear issues, projects, and cycles through the Integrate MCP server. Installation [#installation] The Linear integration is included with the SDK: ```typescript import { linearIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Linear OAuth App [#1-create-a-linear-oauth-app] 1. Go to [Linear Settings](https://linear.app/settings/api) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Linear integration to your server configuration. The integration automatically reads `LINEAR_CLIENT_ID` and `LINEAR_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, linearIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ linearIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript linearIntegration({ clientId: process.env.CUSTOM_LINEAR_ID, clientSecret: process.env.CUSTOM_LINEAR_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("linear"); const result = await client.linear.createIssue({ teamId: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, linearIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [linearIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] linear_create_issue [#linear_create_issue] Create a new issue in Linear linear_list_issues [#linear_list_issues] List issues in Linear linear_get_issue [#linear_get_issue] Get a specific issue by ID or identifier linear_update_issue [#linear_update_issue] Update an existing issue linear_archive_issue [#linear_archive_issue] Archive an issue linear_delete_issue [#linear_delete_issue] Delete an issue permanently linear_search_issues [#linear_search_issues] Search for issues linear_add_comment [#linear_add_comment] Add a comment to an issue linear_list_users [#linear_list_users] List users in the workspace linear_get_user [#linear_get_user] Get a specific user by ID linear_list_teams [#linear_list_teams] List teams in Linear linear_list_workflow_states [#linear_list_workflow_states] List workflow states linear_create_workflow_state [#linear_create_workflow_state] Create a new workflow state linear_list_projects [#linear_list_projects] List projects in Linear linear_get_project [#linear_get_project] Get a specific project by ID linear_create_project [#linear_create_project] Create a new project linear_update_project [#linear_update_project] Update an existing project linear_list_cycles [#linear_list_cycles] List cycles (sprints) linear_get_cycle [#linear_get_cycle] Get a specific cycle by ID linear_create_cycle [#linear_create_cycle] Create a new cycle (sprint) linear_update_cycle [#linear_update_cycle] Update an existing cycle linear_list_labels [#linear_list_labels] List labels in Linear linear_create_issue_relation [#linear_create_issue_relation] Create a relation between two issues linear_delete_issue_relation [#linear_delete_issue_relation] Delete an issue relation linear_list_documents [#linear_list_documents] List documents linear_get_document [#linear_get_document] Get a specific document by ID linear_create_document [#linear_create_document] Create a new document linear_update_document [#linear_update_document] Update an existing document linear_list_initiatives [#linear_list_initiatives] List initiatives linear_get_initiative [#linear_get_initiative] Get a specific initiative by ID linear_create_initiative [#linear_create_initiative] Create a new initiative linear_create_attachment [#linear_create_attachment] Create an attachment (link) on an issue linear_create_project_update [#linear_create_project_update] Create a status update for a project Notes [#notes] * Category: Engineering * Authentication mode: OAuth # LinkedIn Integration The LinkedIn integration provides access to read LinkedIn OpenID profile data and publish member posts through the Integrate MCP server. Installation [#installation] The LinkedIn integration is included with the SDK: ```typescript import { linkedinIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a LinkedIn OAuth App [#1-create-a-linkedin-oauth-app] 1. Go to [Linkedin Developer Portal](https://www.linkedin.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the LinkedIn integration to your server configuration. The integration automatically reads `LINKEDIN_CLIENT_ID` and `LINKEDIN_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, linkedinIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ linkedinIntegration({ scopes: ["openid", "profile", "email", "w_member_social"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript linkedinIntegration({ clientId: process.env.CUSTOM_LINKEDIN_ID, clientSecret: process.env.CUSTOM_LINKEDIN_SECRET, scopes: ["openid", "profile", "email", "w_member_social"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("linkedin"); const result = await client.linkedin.getUserinfo({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, linkedinIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [linkedinIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `openid` * `profile` * `email` * `w_member_social` Tools [#tools] linkedin_get_userinfo [#linkedin_get_userinfo] Get userinfo *No parameters.* linkedin_create_post [#linkedin_create_post] Create post Notes [#notes] * Category: Social Media * Authentication mode: OAuth # Looker Integration The Looker integration provides access to manage Looker me, search dashboards, get dashboard, run query, list looks through the Integrate MCP server. Installation [#installation] The Looker integration is included with the SDK: ```typescript import { lookerIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Looker OAuth App [#1-create-a-looker-oauth-app] 1. Create an OAuth application for Looker 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Looker integration to your server configuration. The integration automatically reads `LOOKER_CLIENT_ID` and `LOOKER_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, lookerIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ lookerIntegration({ scopes: ["read", "write"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript lookerIntegration({ clientId: process.env.CUSTOM_LOOKER_ID, clientSecret: process.env.CUSTOM_LOOKER_SECRET, scopes: ["read", "write"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("looker"); const result = await client.looker.me({ looker_base_url: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, lookerIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [lookerIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `read` * `write` Tools [#tools] looker_me [#looker_me] Me looker_search_dashboards [#looker_search_dashboards] Search dashboards looker_get_dashboard [#looker_get_dashboard] Get dashboard looker_run_query [#looker_run_query] Run query looker_list_looks [#looker_list_looks] List looks looker_get_look [#looker_get_look] Get look Notes [#notes] * Category: Data & BI * Authentication mode: OAuth # Mailchimp Integration The Mailchimp integration provides access to manage Mailchimp audiences, members, and campaigns through the Integrate MCP server. Installation [#installation] The Mailchimp integration is included with the SDK: ```typescript import { mailchimpIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Mailchimp OAuth App [#1-create-a-mailchimp-oauth-app] 1. Create an OAuth application for Mailchimp 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Mailchimp integration to your server configuration. The integration automatically reads `MAILCHIMP_CLIENT_ID` and `MAILCHIMP_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, mailchimpIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ mailchimpIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript mailchimpIntegration({ clientId: process.env.CUSTOM_MAILCHIMP_ID, clientSecret: process.env.CUSTOM_MAILCHIMP_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("mailchimp"); // Use client.mailchimp methods after connecting ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, mailchimpIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [mailchimpIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] mailchimp_ping [#mailchimp_ping] Ping *No parameters.* mailchimp_list_audiences [#mailchimp_list_audiences] List audiences *No parameters.* mailchimp_get_audience [#mailchimp_get_audience] Get audience *No parameters.* mailchimp_list_members [#mailchimp_list_members] List members *No parameters.* mailchimp_get_member [#mailchimp_get_member] Get member *No parameters.* mailchimp_add_or_update_member [#mailchimp_add_or_update_member] Add or update member *No parameters.* mailchimp_archive_member [#mailchimp_archive_member] Archive member *No parameters.* mailchimp_list_campaigns [#mailchimp_list_campaigns] List campaigns *No parameters.* Notes [#notes] * Category: Marketing * Authentication mode: OAuth # MapMyFitness Integration The MapMyFitness integration provides access to manage MapMyFitness get user, list workouts, get workout, create workout, list routes through the Integrate MCP server. Installation [#installation] The MapMyFitness integration is included with the SDK: ```typescript import { mapmyfitnessIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a MapMyFitness OAuth App [#1-create-a-mapmyfitness-oauth-app] 1. Create an OAuth application for MapMyFitness 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the MapMyFitness integration to your server configuration. The integration automatically reads `MAPMYFITNESS_CLIENT_ID` and `MAPMYFITNESS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, mapmyfitnessIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ mapmyfitnessIntegration({ scopes: ["read", "write"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript mapmyfitnessIntegration({ clientId: process.env.CUSTOM_MAPMYFITNESS_ID, clientSecret: process.env.CUSTOM_MAPMYFITNESS_SECRET, scopes: ["read", "write"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("mapmyfitness"); const result = await client.mapmyfitness.getUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, mapmyfitnessIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [mapmyfitnessIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `read` * `write` Tools [#tools] mapmyfitness_get_user [#mapmyfitness_get_user] Get user *No parameters.* mapmyfitness_list_workouts [#mapmyfitness_list_workouts] List workouts mapmyfitness_get_workout [#mapmyfitness_get_workout] Get workout mapmyfitness_create_workout [#mapmyfitness_create_workout] Create workout mapmyfitness_list_routes [#mapmyfitness_list_routes] List routes Notes [#notes] * Category: Fitness * Authentication mode: OAuth # Meetup Integration The Meetup integration provides access to manage Meetup get self, search groups, list events, get event, create event through the Integrate MCP server. Installation [#installation] The Meetup integration is included with the SDK: ```typescript import { meetupIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Meetup OAuth App [#1-create-a-meetup-oauth-app] 1. Create an OAuth application for Meetup 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Meetup integration to your server configuration. The integration automatically reads `MEETUP_CLIENT_ID` and `MEETUP_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, meetupIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ meetupIntegration({ scopes: ["basic", "event_management", "group_edit", "rsvp"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript meetupIntegration({ clientId: process.env.CUSTOM_MEETUP_ID, clientSecret: process.env.CUSTOM_MEETUP_SECRET, scopes: ["basic", "event_management", "group_edit", "rsvp"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("meetup"); const result = await client.meetup.getSelf({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, meetupIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [meetupIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `basic` * `event_management` * `group_edit` * `rsvp` Tools [#tools] meetup_get_self [#meetup_get_self] Get self *No parameters.* meetup_search_groups [#meetup_search_groups] Search groups meetup_list_events [#meetup_list_events] List events meetup_get_event [#meetup_get_event] Get event meetup_create_event [#meetup_create_event] Create event meetup_rsvp_event [#meetup_rsvp_event] Rsvp event Notes [#notes] * Category: Events & Ticketing * Authentication mode: OAuth # Mercury Integration The Mercury integration provides access to manage Mercury bank accounts, cards, and transactions through the Integrate MCP server. Installation [#installation] The Mercury integration is included with the SDK: ```typescript import { mercuryIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Mercury to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, mercuryIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ mercuryIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; // Use client.mercury methods after connecting ``` Environment Variables [#environment-variables] * `MERCURY_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] mercury_get_organization [#mercury_get_organization] Get organization *No parameters.* mercury_list_accounts [#mercury_list_accounts] List accounts *No parameters.* mercury_get_account [#mercury_get_account] Get account *No parameters.* mercury_get_account_cards [#mercury_get_account_cards] Get account cards *No parameters.* mercury_list_account_transactions [#mercury_list_account_transactions] List account transactions *No parameters.* mercury_get_account_transaction [#mercury_get_account_transaction] Get account transaction *No parameters.* mercury_list_account_statements [#mercury_list_account_statements] List account statements *No parameters.* mercury_download_statement_pdf [#mercury_download_statement_pdf] Download statement pdf *No parameters.* mercury_list_transactions [#mercury_list_transactions] List transactions *No parameters.* mercury_get_transaction [#mercury_get_transaction] Get transaction *No parameters.* mercury_update_transaction [#mercury_update_transaction] Update transaction *No parameters.* mercury_upload_transaction_attachment [#mercury_upload_transaction_attachment] Upload transaction attachment *No parameters.* mercury_list_cards [#mercury_list_cards] List cards *No parameters.* mercury_get_card [#mercury_get_card] Get card *No parameters.* mercury_create_card [#mercury_create_card] Create card *No parameters.* mercury_update_card [#mercury_update_card] Update card *No parameters.* mercury_freeze_card [#mercury_freeze_card] Freeze card *No parameters.* mercury_unfreeze_card [#mercury_unfreeze_card] Unfreeze card *No parameters.* mercury_cancel_card [#mercury_cancel_card] Cancel card *No parameters.* mercury_list_categories [#mercury_list_categories] List categories *No parameters.* mercury_create_category [#mercury_create_category] Create category *No parameters.* mercury_update_category [#mercury_update_category] Update category *No parameters.* mercury_list_credit_accounts [#mercury_list_credit_accounts] List credit accounts *No parameters.* mercury_list_users [#mercury_list_users] List users *No parameters.* mercury_get_user [#mercury_get_user] Get user *No parameters.* mercury_list_recipients [#mercury_list_recipients] List recipients *No parameters.* mercury_get_recipient [#mercury_get_recipient] Get recipient *No parameters.* mercury_create_recipient [#mercury_create_recipient] Create recipient *No parameters.* mercury_update_recipient [#mercury_update_recipient] Update recipient *No parameters.* mercury_list_recipient_attachments [#mercury_list_recipient_attachments] List recipient attachments *No parameters.* mercury_upload_recipient_attachment [#mercury_upload_recipient_attachment] Upload recipient attachment *No parameters.* mercury_list_customers [#mercury_list_customers] List customers *No parameters.* mercury_get_customer [#mercury_get_customer] Get customer *No parameters.* mercury_create_customer [#mercury_create_customer] Create customer *No parameters.* mercury_update_customer [#mercury_update_customer] Update customer *No parameters.* mercury_delete_customer [#mercury_delete_customer] Delete customer *No parameters.* mercury_list_invoices [#mercury_list_invoices] List invoices *No parameters.* mercury_get_invoice [#mercury_get_invoice] Get invoice *No parameters.* mercury_create_invoice [#mercury_create_invoice] Create invoice *No parameters.* mercury_update_invoice [#mercury_update_invoice] Update invoice *No parameters.* mercury_cancel_invoice [#mercury_cancel_invoice] Cancel invoice *No parameters.* mercury_list_invoice_attachments [#mercury_list_invoice_attachments] List invoice attachments *No parameters.* mercury_get_attachment [#mercury_get_attachment] Get attachment *No parameters.* mercury_download_invoice_pdf [#mercury_download_invoice_pdf] Download invoice pdf *No parameters.* mercury_list_treasury_accounts [#mercury_list_treasury_accounts] List treasury accounts *No parameters.* mercury_list_treasury_transactions [#mercury_list_treasury_transactions] List treasury transactions *No parameters.* mercury_list_treasury_statements [#mercury_list_treasury_statements] List treasury statements *No parameters.* mercury_list_events [#mercury_list_events] List events *No parameters.* mercury_get_event [#mercury_get_event] Get event *No parameters.* mercury_list_send_money_requests [#mercury_list_send_money_requests] List send money requests *No parameters.* mercury_get_send_money_request [#mercury_get_send_money_request] Get send money request *No parameters.* mercury_list_safe_requests [#mercury_list_safe_requests] List safe requests *No parameters.* mercury_get_safe_request [#mercury_get_safe_request] Get safe request *No parameters.* mercury_download_safe_request_document [#mercury_download_safe_request_document] Download safe request document *No parameters.* mercury_list_webhooks [#mercury_list_webhooks] List webhooks *No parameters.* mercury_get_webhook [#mercury_get_webhook] Get webhook *No parameters.* mercury_create_webhook [#mercury_create_webhook] Create webhook *No parameters.* mercury_update_webhook [#mercury_update_webhook] Update webhook *No parameters.* mercury_delete_webhook [#mercury_delete_webhook] Delete webhook *No parameters.* mercury_verify_webhook [#mercury_verify_webhook] Verify webhook *No parameters.* mercury_create_internal_transfer [#mercury_create_internal_transfer] Create internal transfer *No parameters.* mercury_send_money [#mercury_send_money] Send money *No parameters.* mercury_request_send_money [#mercury_request_send_money] Request send money *No parameters.* Notes [#notes] * Category: Finance * Authentication mode: API key # Meta Ads Integration The Meta Ads integration provides access to manage Meta Ads list ad accounts, get ad account, list campaigns, create campaign, list adsets through the Integrate MCP server. Installation [#installation] The Meta Ads integration is included with the SDK: ```typescript import { metaAdsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Meta Ads OAuth App [#1-create-a-meta-ads-oauth-app] 1. Create an OAuth application for Meta Ads 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Meta Ads integration to your server configuration. The integration automatically reads `META_ADS_CLIENT_ID` and `META_ADS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, metaAdsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ metaAdsIntegration({ scopes: ["ads_read", "ads_management", "business_management"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript metaAdsIntegration({ clientId: process.env.CUSTOM_META_ADS_ID, clientSecret: process.env.CUSTOM_META_ADS_SECRET, scopes: ["ads_read", "ads_management", "business_management"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("meta_ads"); const result = await client.meta_ads.listAdAccounts({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, metaAdsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [metaAdsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ads_read` * `ads_management` * `business_management` Tools [#tools] meta_ads_list_ad_accounts [#meta_ads_list_ad_accounts] Ads list ad accounts meta_ads_get_ad_account [#meta_ads_get_ad_account] Ads get ad account meta_ads_list_campaigns [#meta_ads_list_campaigns] Ads list campaigns meta_ads_create_campaign [#meta_ads_create_campaign] Ads create campaign meta_ads_list_adsets [#meta_ads_list_adsets] Ads list adsets meta_ads_list_ads [#meta_ads_list_ads] Ads list ads Notes [#notes] * Category: Marketing * Authentication mode: OAuth # Microsoft Ads Integration The Microsoft Ads integration provides access to manage Microsoft Ads get user, search accounts, get campaigns, add campaigns, get ad groups through the Integrate MCP server. Installation [#installation] The Microsoft Ads integration is included with the SDK: ```typescript import { microsoftAdsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Microsoft Ads OAuth App [#1-create-a-microsoft-ads-oauth-app] 1. Go to [Azure Portal β€” App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Microsoft Ads integration to your server configuration. The integration automatically reads `MICROSOFT_ADS_CLIENT_ID` and `MICROSOFT_ADS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, microsoftAdsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ microsoftAdsIntegration({ scopes: ["https://ads.microsoft.com/msads.manage", "offline_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript microsoftAdsIntegration({ clientId: process.env.CUSTOM_MICROSOFT_ADS_ID, clientSecret: process.env.CUSTOM_MICROSOFT_ADS_SECRET, scopes: ["https://ads.microsoft.com/msads.manage", "offline_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("microsoft_ads"); const result = await client.microsoft_ads.getUser({ query_json: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, microsoftAdsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [microsoftAdsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `https://ads.microsoft.com/msads.manage` * `offline_access` Tools [#tools] microsoft_ads_get_user [#microsoft_ads_get_user] Ads get user microsoft_ads_search_accounts [#microsoft_ads_search_accounts] Ads search accounts microsoft_ads_get_campaigns [#microsoft_ads_get_campaigns] Ads get campaigns microsoft_ads_add_campaigns [#microsoft_ads_add_campaigns] Ads add campaigns microsoft_ads_get_ad_groups [#microsoft_ads_get_ad_groups] Ads get ad groups microsoft_ads_get_keywords [#microsoft_ads_get_keywords] Ads get keywords Notes [#notes] * Category: Marketing * Authentication mode: OAuth # Microsoft Bookings Integration The Microsoft Bookings integration provides access to manage Microsoft Bookings businesses, services, staff members, and appointments through the Integrate MCP server. Installation [#installation] The Microsoft Bookings integration is included with the SDK: ```typescript import { microsoftBookingsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Microsoft Bookings OAuth App [#1-create-a-microsoft-bookings-oauth-app] 1. Go to [Azure Portal β€” App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Microsoft Bookings integration to your server configuration. The integration automatically reads `MICROSOFT_BOOKINGS_CLIENT_ID` and `MICROSOFT_BOOKINGS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, microsoftBookingsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ microsoftBookingsIntegration({ scopes: ["offline_access", "User.Read", "Bookings.ReadWrite.All"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript microsoftBookingsIntegration({ clientId: process.env.CUSTOM_MICROSOFT_BOOKINGS_ID, clientSecret: process.env.CUSTOM_MICROSOFT_BOOKINGS_SECRET, scopes: ["offline_access", "User.Read", "Bookings.ReadWrite.All"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("microsoft_bookings"); const result = await client.microsoft_bookings.listBusinesses({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, microsoftBookingsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [microsoftBookingsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `offline_access` * `User.Read` * `Bookings.ReadWrite.All` Tools [#tools] microsoft_bookings_list_businesses [#microsoft_bookings_list_businesses] Bookings list businesses microsoft_bookings_get_business [#microsoft_bookings_get_business] Bookings get business microsoft_bookings_list_services [#microsoft_bookings_list_services] Bookings list services microsoft_bookings_list_staff_members [#microsoft_bookings_list_staff_members] Bookings list staff members microsoft_bookings_list_appointments [#microsoft_bookings_list_appointments] Bookings list appointments microsoft_bookings_create_appointment [#microsoft_bookings_create_appointment] Bookings create appointment Notes [#notes] * Category: Scheduling * Authentication mode: OAuth # Microsoft Entra ID Integration The Microsoft Entra ID integration provides access to manage Microsoft Entra ID list users, get user, create user, list groups, list applications through the Integrate MCP server. Installation [#installation] The Microsoft Entra ID integration is included with the SDK: ```typescript import { microsoftEntraIdIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Microsoft Entra ID OAuth App [#1-create-a-microsoft-entra-id-oauth-app] 1. Go to [Azure Portal β€” App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Microsoft Entra ID integration to your server configuration. The integration automatically reads `MICROSOFT_ENTRA_ID_CLIENT_ID` and `MICROSOFT_ENTRA_ID_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, microsoftEntraIdIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ microsoftEntraIdIntegration({ scopes: ["User.ReadWrite.All", "Group.ReadWrite.All", "Application.ReadWrite.All", "Directory.Read.All", "AuditLog.Read.All", "offline_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript microsoftEntraIdIntegration({ clientId: process.env.CUSTOM_MICROSOFT_ENTRA_ID_ID, clientSecret: process.env.CUSTOM_MICROSOFT_ENTRA_ID_SECRET, scopes: ["User.ReadWrite.All", "Group.ReadWrite.All", "Application.ReadWrite.All", "Directory.Read.All", "AuditLog.Read.All", "offline_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("microsoft_entra_id"); const result = await client.microsoft_entra_id.listUsers({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, microsoftEntraIdIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [microsoftEntraIdIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `User.ReadWrite.All` * `Group.ReadWrite.All` * `Application.ReadWrite.All` * `Directory.Read.All` * `AuditLog.Read.All` * `offline_access` Tools [#tools] microsoft_entra_id_list_users [#microsoft_entra_id_list_users] Entra id list users microsoft_entra_id_get_user [#microsoft_entra_id_get_user] Entra id get user microsoft_entra_id_create_user [#microsoft_entra_id_create_user] Entra id create user microsoft_entra_id_list_groups [#microsoft_entra_id_list_groups] Entra id list groups microsoft_entra_id_list_applications [#microsoft_entra_id_list_applications] Entra id list applications microsoft_entra_id_list_audit_logs [#microsoft_entra_id_list_audit_logs] Entra id list audit logs Notes [#notes] * Category: Identity & Access * Authentication mode: OAuth # Microsoft Graph Education Integration The Microsoft Graph Education integration provides access to manage Microsoft Graph Education list classes, get class, list users, list assignments, create assignment through the Integrate MCP server. Installation [#installation] The Microsoft Graph Education integration is included with the SDK: ```typescript import { microsoftGraphEducationIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Microsoft Graph Education OAuth App [#1-create-a-microsoft-graph-education-oauth-app] 1. Go to [Azure Portal β€” App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Microsoft Graph Education integration to your server configuration. The integration automatically reads `MICROSOFT_GRAPH_EDUCATION_CLIENT_ID` and `MICROSOFT_GRAPH_EDUCATION_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, microsoftGraphEducationIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ microsoftGraphEducationIntegration({ scopes: ["EduRoster.ReadWrite", "EduAssignments.ReadWrite", "offline_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript microsoftGraphEducationIntegration({ clientId: process.env.CUSTOM_MICROSOFT_GRAPH_EDUCATION_ID, clientSecret: process.env.CUSTOM_MICROSOFT_GRAPH_EDUCATION_SECRET, scopes: ["EduRoster.ReadWrite", "EduAssignments.ReadWrite", "offline_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("microsoft_graph_education"); const result = await client.microsoft_graph_education.listClasses({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, microsoftGraphEducationIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [microsoftGraphEducationIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `EduRoster.ReadWrite` * `EduAssignments.ReadWrite` * `offline_access` Tools [#tools] microsoft_graph_education_list_classes [#microsoft_graph_education_list_classes] Graph education list classes microsoft_graph_education_get_class [#microsoft_graph_education_get_class] Graph education get class microsoft_graph_education_list_users [#microsoft_graph_education_list_users] Graph education list users microsoft_graph_education_list_assignments [#microsoft_graph_education_list_assignments] Graph education list assignments microsoft_graph_education_create_assignment [#microsoft_graph_education_create_assignment] Graph education create assignment microsoft_graph_education_list_schools [#microsoft_graph_education_list_schools] Graph education list schools Notes [#notes] * Category: Education * Authentication mode: OAuth # Microsoft To Do Integration The Microsoft To Do integration provides access to manage Microsoft To Do task lists and tasks through Microsoft Graph through the Integrate MCP server. Installation [#installation] The Microsoft To Do integration is included with the SDK: ```typescript import { microsoftToDoIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Microsoft To Do OAuth App [#1-create-a-microsoft-to-do-oauth-app] 1. Go to [Azure Portal β€” App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Microsoft To Do integration to your server configuration. The integration automatically reads `MICROSOFT_TO_DO_CLIENT_ID` and `MICROSOFT_TO_DO_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, microsoftToDoIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ microsoftToDoIntegration({ scopes: ["offline_access", "User.Read", "Tasks.ReadWrite"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript microsoftToDoIntegration({ clientId: process.env.CUSTOM_MICROSOFT_TO_DO_ID, clientSecret: process.env.CUSTOM_MICROSOFT_TO_DO_SECRET, scopes: ["offline_access", "User.Read", "Tasks.ReadWrite"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("microsoft_to_do"); const result = await client.microsoft_to_do.listTaskLists({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, microsoftToDoIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [microsoftToDoIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `offline_access` * `User.Read` * `Tasks.ReadWrite` Tools [#tools] microsoft_to_do_list_task_lists [#microsoft_to_do_list_task_lists] To do list task lists microsoft_to_do_get_task_list [#microsoft_to_do_get_task_list] To do get task list microsoft_to_do_create_task_list [#microsoft_to_do_create_task_list] To do create task list microsoft_to_do_list_tasks [#microsoft_to_do_list_tasks] To do list tasks microsoft_to_do_get_task [#microsoft_to_do_get_task] To do get task microsoft_to_do_create_task [#microsoft_to_do_create_task] To do create task microsoft_to_do_update_task [#microsoft_to_do_update_task] To do update task Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Miele Integration The Miele integration provides access to manage Miele list devices, get device, get actions, execute action, get programs through the Integrate MCP server. Installation [#installation] The Miele integration is included with the SDK: ```typescript import { mieleIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Miele OAuth App [#1-create-a-miele-oauth-app] 1. Create an OAuth application for Miele 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Miele integration to your server configuration. The integration automatically reads `MIELE_CLIENT_ID` and `MIELE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, mieleIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ mieleIntegration({ scopes: ["openid", "offline_access", "read", "write"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript mieleIntegration({ clientId: process.env.CUSTOM_MIELE_ID, clientSecret: process.env.CUSTOM_MIELE_SECRET, scopes: ["openid", "offline_access", "read", "write"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("miele"); const result = await client.miele.listDevices({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, mieleIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [mieleIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `openid` * `offline_access` * `read` * `write` Tools [#tools] miele_list_devices [#miele_list_devices] List devices miele_get_device [#miele_get_device] Get device miele_get_actions [#miele_get_actions] Get actions miele_execute_action [#miele_execute_action] Execute action miele_get_programs [#miele_get_programs] Get programs Notes [#notes] * Category: Lifestyle * Authentication mode: OAuth # Miro Integration The Miro integration provides access to manage Miro boards, board items, comments, members, and collaborators through the Integrate MCP server. Installation [#installation] The Miro integration is included with the SDK: ```typescript import { miroIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Miro OAuth App [#1-create-a-miro-oauth-app] 1. Create an OAuth application for Miro 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Miro integration to your server configuration. The integration automatically reads `MIRO_CLIENT_ID` and `MIRO_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, miroIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ miroIntegration({ scopes: ["boards:read", "boards:write", "identity:read", "team:read"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript miroIntegration({ clientId: process.env.CUSTOM_MIRO_ID, clientSecret: process.env.CUSTOM_MIRO_SECRET, scopes: ["boards:read", "boards:write", "identity:read", "team:read"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("miro"); const result = await client.miro.getCurrentUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, miroIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [miroIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `boards:read` * `boards:write` * `identity:read` * `team:read` Tools [#tools] miro_get_current_user [#miro_get_current_user] Get current user *No parameters.* miro_list_boards [#miro_list_boards] List boards miro_get_board [#miro_get_board] Get board miro_create_board [#miro_create_board] Create board miro_list_board_items [#miro_list_board_items] List board items miro_create_board_item [#miro_create_board_item] Create board item miro_list_comments [#miro_list_comments] List comments miro_list_board_members [#miro_list_board_members] List board members Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Monday.com Integration The Monday.com integration provides access to manage Monday.com boards, items, columns, and updates through the Integrate MCP server. Installation [#installation] The Monday.com integration is included with the SDK: ```typescript import { mondayIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Monday.com OAuth App [#1-create-a-mondaycom-oauth-app] 1. Go to [Auth Developer Portal](https://auth.monday.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Monday.com integration to your server configuration. The integration automatically reads `MONDAY_CLIENT_ID` and `MONDAY_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, mondayIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ mondayIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript mondayIntegration({ clientId: process.env.CUSTOM_MONDAY_ID, clientSecret: process.env.CUSTOM_MONDAY_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("monday"); const result = await client.monday.me({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, mondayIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [mondayIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] monday_me [#monday_me] Me *No parameters.* monday_list_workspaces [#monday_list_workspaces] List workspaces *No parameters.* monday_list_boards [#monday_list_boards] List boards monday_get_board [#monday_get_board] Get board monday_list_board_items [#monday_list_board_items] List board items monday_next_items_page [#monday_next_items_page] Next items page monday_get_items [#monday_get_items] Get items monday_create_item [#monday_create_item] Create item monday_update_item_columns [#monday_update_item_columns] Update item columns monday_create_update [#monday_create_update] Create update monday_delete_item [#monday_delete_item] Delete item Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Moneybird Integration The Moneybird integration provides access to manage Moneybird list administrations, list contacts, create contact, list sales invoices, create sales invoice through the Integrate MCP server. Installation [#installation] The Moneybird integration is included with the SDK: ```typescript import { moneybirdIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Moneybird OAuth App [#1-create-a-moneybird-oauth-app] 1. Create an OAuth application for Moneybird 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Moneybird integration to your server configuration. The integration automatically reads `MONEYBIRD_CLIENT_ID` and `MONEYBIRD_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, moneybirdIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ moneybirdIntegration({ scopes: ["sales_invoices", "documents", "estimates", "bank", "settings"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript moneybirdIntegration({ clientId: process.env.CUSTOM_MONEYBIRD_ID, clientSecret: process.env.CUSTOM_MONEYBIRD_SECRET, scopes: ["sales_invoices", "documents", "estimates", "bank", "settings"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("moneybird"); const result = await client.moneybird.listAdministrations({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, moneybirdIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [moneybirdIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `sales_invoices` * `documents` * `estimates` * `bank` * `settings` Tools [#tools] moneybird_list_administrations [#moneybird_list_administrations] List administrations *No parameters.* moneybird_list_contacts [#moneybird_list_contacts] List contacts moneybird_create_contact [#moneybird_create_contact] Create contact moneybird_list_sales_invoices [#moneybird_list_sales_invoices] List sales invoices moneybird_create_sales_invoice [#moneybird_create_sales_invoice] Create sales invoice moneybird_list_financial_accounts [#moneybird_list_financial_accounts] List financial accounts Notes [#notes] * Category: Accounting * Authentication mode: OAuth # Neon Integration The Neon integration provides access to manage Neon Postgres projects, branches, API keys, and connection strings through the Integrate MCP server. Installation [#installation] The Neon integration is included with the SDK: ```typescript import { neonIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Neon to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, neonIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ neonIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.neon.listApiKeys({}); console.log(result); ``` Environment Variables [#environment-variables] * `NEON_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] neon_list_api_keys [#neon_list_api_keys] List api keys *No parameters.* neon_create_api_key [#neon_create_api_key] Create api key neon_revoke_api_key [#neon_revoke_api_key] Revoke api key neon_list_organizations [#neon_list_organizations] List organizations *No parameters.* neon_list_projects [#neon_list_projects] List projects neon_list_shared_projects [#neon_list_shared_projects] List shared projects neon_create_project [#neon_create_project] Create project neon_get_project [#neon_get_project] Get project neon_update_project [#neon_update_project] Update project neon_delete_project [#neon_delete_project] Delete project neon_recover_project [#neon_recover_project] Recover project neon_list_branches [#neon_list_branches] List branches neon_create_branch [#neon_create_branch] Create branch neon_get_branch [#neon_get_branch] Get branch neon_delete_branch [#neon_delete_branch] Delete branch neon_list_operations [#neon_list_operations] List operations neon_get_operation [#neon_get_operation] Get operation neon_get_connection_uri [#neon_get_connection_uri] Get connection uri Notes [#notes] * Category: Infrastructure * Authentication mode: API key # Netatmo Integration The Netatmo integration provides access to manage Netatmo get homesdata, get stationsdata, get measure, set thermpoint, get events through the Integrate MCP server. Installation [#installation] The Netatmo integration is included with the SDK: ```typescript import { netatmoIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Netatmo OAuth App [#1-create-a-netatmo-oauth-app] 1. Create an OAuth application for Netatmo 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Netatmo integration to your server configuration. The integration automatically reads `NETATMO_CLIENT_ID` and `NETATMO_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, netatmoIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ netatmoIntegration({ scopes: ["read_station", "read_thermostat", "write_thermostat", "read_camera", "access_camera", "read_presence", "write_presence", "read_homecoach"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript netatmoIntegration({ clientId: process.env.CUSTOM_NETATMO_ID, clientSecret: process.env.CUSTOM_NETATMO_SECRET, scopes: ["read_station", "read_thermostat", "write_thermostat", "read_camera", "access_camera", "read_presence", "write_presence", "read_homecoach"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("netatmo"); const result = await client.netatmo.getHomesdata({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, netatmoIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [netatmoIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `read_station` * `read_thermostat` * `write_thermostat` * `read_camera` * `access_camera` * `read_presence` * `write_presence` * `read_homecoach` Tools [#tools] netatmo_get_homesdata [#netatmo_get_homesdata] Get homesdata netatmo_get_stationsdata [#netatmo_get_stationsdata] Get stationsdata netatmo_get_measure [#netatmo_get_measure] Get measure netatmo_set_thermpoint [#netatmo_set_thermpoint] Set thermpoint netatmo_get_events [#netatmo_get_events] Get events Notes [#notes] * Category: Lifestyle * Authentication mode: OAuth # Netlify Integration The Netlify integration provides access to manage Netlify sites, deploys, builds, and environment variables through the Integrate MCP server. Installation [#installation] The Netlify integration is included with the SDK: ```typescript import { netlifyIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Netlify OAuth App [#1-create-a-netlify-oauth-app] 1. Go to [App Developer Portal](https://app.netlify.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Netlify integration to your server configuration. The integration automatically reads `NETLIFY_CLIENT_ID` and `NETLIFY_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, netlifyIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ netlifyIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript netlifyIntegration({ clientId: process.env.CUSTOM_NETLIFY_ID, clientSecret: process.env.CUSTOM_NETLIFY_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("netlify"); const result = await client.netlify.getCurrentUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, netlifyIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [netlifyIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] netlify_get_current_user [#netlify_get_current_user] Get current user *No parameters.* netlify_list_accounts [#netlify_list_accounts] List accounts *No parameters.* netlify_get_account [#netlify_get_account] Get account netlify_list_sites [#netlify_list_sites] List sites netlify_get_site [#netlify_get_site] Get site netlify_create_site [#netlify_create_site] Create site netlify_update_site [#netlify_update_site] Update site netlify_delete_site [#netlify_delete_site] Delete site netlify_enable_site [#netlify_enable_site] Enable site netlify_disable_site [#netlify_disable_site] Disable site netlify_list_deploys [#netlify_list_deploys] List deploys netlify_get_deploy [#netlify_get_deploy] Get deploy netlify_create_deploy [#netlify_create_deploy] Create deploy netlify_cancel_deploy [#netlify_cancel_deploy] Cancel deploy netlify_restore_deploy [#netlify_restore_deploy] Restore deploy netlify_lock_deploy [#netlify_lock_deploy] Lock deploy netlify_unlock_deploy [#netlify_unlock_deploy] Unlock deploy netlify_list_builds [#netlify_list_builds] List builds netlify_get_build [#netlify_get_build] Get build netlify_trigger_build [#netlify_trigger_build] Trigger build netlify_list_env_vars [#netlify_list_env_vars] List env vars netlify_get_env_var [#netlify_get_env_var] Get env var netlify_create_env_vars [#netlify_create_env_vars] Create env vars netlify_update_env_var [#netlify_update_env_var] Update env var netlify_delete_env_var [#netlify_delete_env_var] Delete env var netlify_list_build_hooks [#netlify_list_build_hooks] List build hooks netlify_create_build_hook [#netlify_create_build_hook] Create build hook netlify_delete_build_hook [#netlify_delete_build_hook] Delete build hook netlify_list_forms [#netlify_list_forms] List forms netlify_list_form_submissions [#netlify_list_form_submissions] List form submissions netlify_list_dns_zones [#netlify_list_dns_zones] List dns zones *No parameters.* netlify_get_dns_records [#netlify_get_dns_records] Get dns records netlify_create_dns_record [#netlify_create_dns_record] Create dns record netlify_delete_dns_record [#netlify_delete_dns_record] Delete dns record netlify_list_functions [#netlify_list_functions] List functions netlify_list_files [#netlify_list_files] List files netlify_purge_cache [#netlify_purge_cache] Purge cache Notes [#notes] * Category: Infrastructure * Authentication mode: OAuth # Notion Integration The Notion integration provides access to manage Notion pages and databases through the Integrate MCP server. Installation [#installation] The Notion integration is included with the SDK: ```typescript import { notionIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Notion OAuth App [#1-create-a-notion-oauth-app] 1. Go to [Notion Integrations](https://www.notion.so/my-integrations) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Notion integration to your server configuration. The integration automatically reads `NOTION_CLIENT_ID` and `NOTION_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, notionIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ notionIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript notionIntegration({ clientId: process.env.CUSTOM_NOTION_ID, clientSecret: process.env.CUSTOM_NOTION_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("notion"); const result = await client.notion.search({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, notionIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [notionIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] notion_search [#notion_search] Search for pages and databases in Notion notion_get_page [#notion_get_page] Retrieve a Notion page by ID notion_create_page [#notion_create_page] Create a new page under a page or database parent notion_update_page [#notion_update_page] Update a page's properties, icon, cover, or archive status notion_get_page_property [#notion_get_page_property] Get a specific property value from a page with pagination support notion_get_database [#notion_get_database] Get a database by ID including its schema notion_query_database [#notion_query_database] Query a database with filters, sorts, and pagination notion_create_database [#notion_create_database] Create a new database under a parent page notion_update_database [#notion_update_database] Update a database's title, description, properties, or archive status notion_get_block [#notion_get_block] Get a block by ID notion_get_block_children [#notion_get_block_children] Get child blocks of a block with pagination notion_append_blocks [#notion_append_blocks] Append child blocks to a parent block notion_update_block [#notion_update_block] Update a block's content notion_delete_block [#notion_delete_block] Delete (archive) a block notion_get_user [#notion_get_user] Get a user by ID notion_get_current_user [#notion_get_current_user] Get the bot user associated with the current token *No parameters.* notion_list_users [#notion_list_users] List workspace users with pagination notion_create_comment [#notion_create_comment] Create a comment on a page or reply to a discussion notion_list_comments [#notion_list_comments] List comments on a block or page notion_move_page [#notion_move_page] Move a page to a new parent page or data source notion_create_file_upload [#notion_create_file_upload] Create a Notion file upload. Use mode "external\_url" to import from a URL, notion_send_file_upload [#notion_send_file_upload] Send file content for a Notion file upload (single\_part mode). notion_complete_file_upload [#notion_complete_file_upload] Complete a Notion file upload after sending content notion_get_file_upload [#notion_get_file_upload] Get the status of a Notion file upload notion_create_data_source [#notion_create_data_source] Create a new Notion data source under a parent page notion_get_data_source [#notion_get_data_source] Get a Notion data source by its ID notion_update_data_source [#notion_update_data_source] Update a Notion data source's title, description, properties, or status notion_query_data_source [#notion_query_data_source] Query a Notion data source with optional filters, sorts, and pagination Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Okta Integration The Okta integration provides access to manage Okta users, groups, apps, authorization servers, policies, and system logs through the Integrate MCP server. Installation [#installation] The Okta integration is included with the SDK: ```typescript import { oktaIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Okta OAuth App [#1-create-an-okta-oauth-app] 1. Create an OAuth application for Okta 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Okta integration to your server configuration. The integration automatically reads `OKTA_CLIENT_ID` and `OKTA_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, oktaIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ oktaIntegration({ scopes: ["openid", "profile", "email", "offline_access", "okta.users.read", "okta.users.manage", "okta.groups.read", "okta.groups.manage", "okta.apps.read", "okta.logs.read"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript oktaIntegration({ clientId: process.env.CUSTOM_OKTA_ID, clientSecret: process.env.CUSTOM_OKTA_SECRET, scopes: ["openid", "profile", "email", "offline_access", "okta.users.read", "okta.users.manage", "okta.groups.read", "okta.groups.manage", "okta.apps.read", "okta.logs.read"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("okta"); const result = await client.okta.listUsers({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, oktaIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [oktaIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `openid` * `profile` * `email` * `offline_access` * `okta.users.read` * `okta.users.manage` * `okta.groups.read` * `okta.groups.manage` * `okta.apps.read` * `okta.logs.read` Tools [#tools] okta_list_users [#okta_list_users] List users okta_get_user [#okta_get_user] Get user okta_create_user [#okta_create_user] Create user okta_update_user [#okta_update_user] Update user okta_deactivate_user [#okta_deactivate_user] Deactivate user okta_list_groups [#okta_list_groups] List groups okta_get_group [#okta_get_group] Get group okta_create_group [#okta_create_group] Create group okta_add_user_to_group [#okta_add_user_to_group] Add user to group okta_remove_user_from_group [#okta_remove_user_from_group] Remove user from group okta_list_apps [#okta_list_apps] List apps okta_get_app [#okta_get_app] Get app okta_list_authorization_servers [#okta_list_authorization_servers] List authorization servers okta_list_policies [#okta_list_policies] List policies okta_list_system_logs [#okta_list_system_logs] List system logs Notes [#notes] * Category: Identity & Access * Authentication mode: OAuth # OneDrive Integration The OneDrive integration provides access to manage OneDrive files, folders, and sharing through the Integrate MCP server. Installation [#installation] The OneDrive integration is included with the SDK: ```typescript import { onedriveIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an OneDrive OAuth App [#1-create-an-onedrive-oauth-app] 1. Go to [Azure Portal β€” App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the OneDrive integration to your server configuration. The integration automatically reads `ONEDRIVE_CLIENT_ID` and `ONEDRIVE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, onedriveIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ onedriveIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript onedriveIntegration({ clientId: process.env.CUSTOM_ONEDRIVE_ID, clientSecret: process.env.CUSTOM_ONEDRIVE_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("onedrive"); const result = await client.onedrive.listFiles({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, onedriveIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [onedriveIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] onedrive_create_folder [#onedrive_create_folder] Create folder onedrive_delete_file [#onedrive_delete_file] Delete a file or folder permanently onedrive_download_file [#onedrive_download_file] Get the download URL for a file onedrive_get_file [#onedrive_get_file] Get metadata for a file or folder onedrive_list_files [#onedrive_list_files] List files and folders in OneDrive onedrive_list_permissions [#onedrive_list_permissions] List permissions onedrive_remove_permission [#onedrive_remove_permission] Remove permission onedrive_search_files [#onedrive_search_files] Search across all files in OneDrive onedrive_share_file [#onedrive_share_file] Create a sharing link for a file or folder onedrive_upload_file [#onedrive_upload_file] Upload a file to OneDrive Notes [#notes] * Category: Storage * Authentication mode: OAuth # OneLogin Integration The OneLogin integration provides access to manage OneLogin list users, get user, create user, list roles, list apps through the Integrate MCP server. Installation [#installation] The OneLogin integration is included with the SDK: ```typescript import { oneloginIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an OneLogin OAuth App [#1-create-an-onelogin-oauth-app] 1. Create an OAuth application for OneLogin 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the OneLogin integration to your server configuration. The integration automatically reads `ONELOGIN_CLIENT_ID` and `ONELOGIN_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, oneloginIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ oneloginIntegration({ scopes: ["openid", "profile", "manage:all"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript oneloginIntegration({ clientId: process.env.CUSTOM_ONELOGIN_ID, clientSecret: process.env.CUSTOM_ONELOGIN_SECRET, scopes: ["openid", "profile", "manage:all"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("onelogin"); const result = await client.onelogin.listUsers({ region: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, oneloginIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [oneloginIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `openid` * `profile` * `manage:all` Tools [#tools] onelogin_list_users [#onelogin_list_users] List users onelogin_get_user [#onelogin_get_user] Get user onelogin_create_user [#onelogin_create_user] Create user onelogin_list_roles [#onelogin_list_roles] List roles onelogin_list_apps [#onelogin_list_apps] List apps onelogin_list_events [#onelogin_list_events] List events Notes [#notes] * Category: Identity & Access * Authentication mode: OAuth # OneNote Integration The OneNote integration provides access to manage OneNote notebooks, sections, pages, and section creation through Microsoft Graph through the Integrate MCP server. Installation [#installation] The OneNote integration is included with the SDK: ```typescript import { onenoteIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an OneNote OAuth App [#1-create-an-onenote-oauth-app] 1. Go to [Azure Portal β€” App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the OneNote integration to your server configuration. The integration automatically reads `ONENOTE_CLIENT_ID` and `ONENOTE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, onenoteIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ onenoteIntegration({ scopes: ["offline_access", "User.Read", "Notes.ReadWrite.All"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript onenoteIntegration({ clientId: process.env.CUSTOM_ONENOTE_ID, clientSecret: process.env.CUSTOM_ONENOTE_SECRET, scopes: ["offline_access", "User.Read", "Notes.ReadWrite.All"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("onenote"); const result = await client.onenote.listNotebooks({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, onenoteIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [onenoteIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `offline_access` * `User.Read` * `Notes.ReadWrite.All` Tools [#tools] onenote_list_notebooks [#onenote_list_notebooks] List notebooks onenote_get_notebook [#onenote_get_notebook] Get notebook onenote_list_sections [#onenote_list_sections] List sections onenote_create_section [#onenote_create_section] Create section onenote_list_pages [#onenote_list_pages] List pages onenote_get_page [#onenote_get_page] Get page Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Oura Integration The Oura integration provides access to manage Oura get personal info, list daily activity, list sleep, list workouts, list sessions through the Integrate MCP server. Installation [#installation] The Oura integration is included with the SDK: ```typescript import { ouraIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Oura OAuth App [#1-create-an-oura-oauth-app] 1. Create an OAuth application for Oura 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Oura integration to your server configuration. The integration automatically reads `OURA_CLIENT_ID` and `OURA_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, ouraIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ ouraIntegration({ scopes: ["email", "personal", "daily", "heartrate", "workout", "session", "tag"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript ouraIntegration({ clientId: process.env.CUSTOM_OURA_ID, clientSecret: process.env.CUSTOM_OURA_SECRET, scopes: ["email", "personal", "daily", "heartrate", "workout", "session", "tag"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("oura"); const result = await client.oura.getPersonalInfo({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, ouraIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [ouraIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `email` * `personal` * `daily` * `heartrate` * `workout` * `session` * `tag` Tools [#tools] oura_get_personal_info [#oura_get_personal_info] Get personal info *No parameters.* oura_list_daily_activity [#oura_list_daily_activity] List daily activity oura_list_sleep [#oura_list_sleep] List sleep oura_list_workouts [#oura_list_workouts] List workouts oura_list_sessions [#oura_list_sessions] List sessions oura_list_tags [#oura_list_tags] List tags Notes [#notes] * Category: Fitness * Authentication mode: OAuth # Outlook Integration The Outlook integration provides access to manage Outlook mail, calendars, and contacts through the Integrate MCP server. Installation [#installation] The Outlook integration is included with the SDK: ```typescript import { outlookIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Outlook OAuth App [#1-create-an-outlook-oauth-app] 1. Go to [Azure Portal β€” App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Outlook integration to your server configuration. The integration automatically reads `OUTLOOK_CLIENT_ID` and `OUTLOOK_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, outlookIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ outlookIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript outlookIntegration({ clientId: process.env.CUSTOM_OUTLOOK_ID, clientSecret: process.env.CUSTOM_OUTLOOK_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("outlook"); const result = await client.outlook.listMessages({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, outlookIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [outlookIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] outlook_accept_event [#outlook_accept_event] Accept a calendar event invitation outlook_create_draft [#outlook_create_draft] Create a draft message (not sent) outlook_create_event [#outlook_create_event] Create a new calendar event outlook_decline_event [#outlook_decline_event] Decline a calendar event invitation outlook_delete_event [#outlook_delete_event] Delete a calendar event outlook_delete_message [#outlook_delete_message] Delete a message permanently outlook_find_meeting_times [#outlook_find_meeting_times] Find available meeting times for a set of attendees outlook_forward_message [#outlook_forward_message] Forward a message to one or more recipients outlook_get_contact [#outlook_get_contact] Get a specific contact by ID outlook_get_event [#outlook_get_event] Get a specific calendar event by ID outlook_get_message [#outlook_get_message] Get a specific message by ID outlook_get_schedule [#outlook_get_schedule] Get free/busy schedule for a set of users or resources outlook_list_calendars [#outlook_list_calendars] List all calendars for the authenticated user *No parameters.* outlook_list_contacts [#outlook_list_contacts] List contacts in the address book outlook_list_events [#outlook_list_events] List calendar events outlook_list_mail_folders [#outlook_list_mail_folders] List mail folders in the mailbox outlook_list_messages [#outlook_list_messages] List messages in the mailbox outlook_mark_message_read [#outlook_mark_message_read] Mark a message as read or unread outlook_move_message [#outlook_move_message] Move a message to another folder outlook_reply_all_message [#outlook_reply_all_message] Reply all to a message outlook_reply_message [#outlook_reply_message] Reply to a message outlook_search_messages [#outlook_search_messages] Search messages by keyword query outlook_send_message [#outlook_send_message] Send a new email message outlook_tentatively_accept_event [#outlook_tentatively_accept_event] Tentatively accept a calendar event invitation outlook_update_event [#outlook_update_event] Update an existing calendar event Notes [#notes] * Category: Communication * Authentication mode: OAuth # PandaDoc Integration The PandaDoc integration provides access to manage PandaDoc list documents, get document, create document, send document, list templates through the Integrate MCP server. Installation [#installation] The PandaDoc integration is included with the SDK: ```typescript import { pandadocIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a PandaDoc OAuth App [#1-create-a-pandadoc-oauth-app] 1. Create an OAuth application for PandaDoc 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the PandaDoc integration to your server configuration. The integration automatically reads `PANDADOC_CLIENT_ID` and `PANDADOC_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, pandadocIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ pandadocIntegration({ scopes: ["read+write"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript pandadocIntegration({ clientId: process.env.CUSTOM_PANDADOC_ID, clientSecret: process.env.CUSTOM_PANDADOC_SECRET, scopes: ["read+write"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("pandadoc"); const result = await client.pandadoc.listDocuments({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, pandadocIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [pandadocIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `read+write` Tools [#tools] pandadoc_list_documents [#pandadoc_list_documents] List documents pandadoc_get_document [#pandadoc_get_document] Get document pandadoc_create_document [#pandadoc_create_document] Create document pandadoc_send_document [#pandadoc_send_document] Send document pandadoc_list_templates [#pandadoc_list_templates] List templates pandadoc_create_session [#pandadoc_create_session] Create session Notes [#notes] * Category: Legal * Authentication mode: OAuth # Dropbox Paper Integration The Dropbox Paper integration provides access to create, update, and export Dropbox Paper documents through the Integrate MCP server. Installation [#installation] The Dropbox Paper integration is included with the SDK: ```typescript import { paperIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Dropbox Paper OAuth App [#1-create-a-dropbox-paper-oauth-app] 1. Go to [Dropbox Developer Portal](https://www.dropbox.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Dropbox Paper integration to your server configuration. The integration automatically reads `PAPER_CLIENT_ID` and `PAPER_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, paperIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ paperIntegration({ scopes: ["account_info.read", "files.metadata.read", "files.content.read", "files.content.write"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript paperIntegration({ clientId: process.env.CUSTOM_PAPER_ID, clientSecret: process.env.CUSTOM_PAPER_SECRET, scopes: ["account_info.read", "files.metadata.read", "files.content.read", "files.content.write"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("paper"); const result = await client.paper.createDoc({ path: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, paperIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [paperIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `account_info.read` * `files.metadata.read` * `files.content.read` * `files.content.write` Tools [#tools] paper_create_doc [#paper_create_doc] Create doc paper_update_doc [#paper_update_doc] Update doc paper_export_doc [#paper_export_doc] Export doc Notes [#notes] * Category: Productivity * Authentication mode: OAuth # PayPal Integration The PayPal integration provides access to manage PayPal orders, captures, refunds, invoices, products, plans, and subscriptions through the Integrate MCP server. Installation [#installation] The PayPal integration is included with the SDK: ```typescript import { paypalIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add PayPal to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, paypalIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ paypalIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.paypal.createOrder({ order_json: "value", }); console.log(result); ``` Environment Variables [#environment-variables] * `PAYPAL_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] paypal_create_order [#paypal_create_order] Create order paypal_get_order [#paypal_get_order] Get order paypal_capture_order [#paypal_capture_order] Capture order paypal_get_capture [#paypal_get_capture] Get capture paypal_refund_capture [#paypal_refund_capture] Refund capture paypal_get_refund [#paypal_get_refund] Get refund paypal_list_invoices [#paypal_list_invoices] List invoices paypal_get_invoice [#paypal_get_invoice] Get invoice paypal_create_invoice [#paypal_create_invoice] Create invoice paypal_send_invoice [#paypal_send_invoice] Send invoice paypal_list_products [#paypal_list_products] List products paypal_create_product [#paypal_create_product] Create product paypal_list_plans [#paypal_list_plans] List plans paypal_create_plan [#paypal_create_plan] Create plan paypal_get_subscription [#paypal_get_subscription] Get subscription paypal_cancel_subscription [#paypal_cancel_subscription] Cancel subscription Notes [#notes] * Category: Finance * Authentication mode: API key # Phantom Integration The Phantom integration provides access to build Phantom mobile universal links and expose provider deeplink reference data through the Integrate MCP server. Installation [#installation] The Phantom integration is included with the SDK: ```typescript import { phantomIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Phantom to your server configuration: ```typescript import { createMCPServer, phantomIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ phantomIntegration(), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.phantom.buildBrowseDeeplink({ url: "value", }); console.log(result); ``` Configuration Options [#configuration-options] Tools [#tools] phantom_build_browse_deeplink [#phantom_build_browse_deeplink] Build browse deeplink phantom_deeplink_provider_reference [#phantom_deeplink_provider_reference] Deeplink provider reference *No parameters.* Notes [#notes] * Category: Other * Authentication mode: None # Philips Hue Integration The Philips Hue integration provides access to manage Philips Hue list bridges, list lights, get light, update light, list rooms through the Integrate MCP server. Installation [#installation] The Philips Hue integration is included with the SDK: ```typescript import { philipsHueIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Philips Hue OAuth App [#1-create-a-philips-hue-oauth-app] 1. Create an OAuth application for Philips Hue 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Philips Hue integration to your server configuration. The integration automatically reads `PHILIPS_HUE_CLIENT_ID` and `PHILIPS_HUE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, philipsHueIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ philipsHueIntegration({ scopes: ["remote_control:all"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript philipsHueIntegration({ clientId: process.env.CUSTOM_PHILIPS_HUE_ID, clientSecret: process.env.CUSTOM_PHILIPS_HUE_SECRET, scopes: ["remote_control:all"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("philips_hue"); const result = await client.philips_hue.listBridges({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, philipsHueIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [philipsHueIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `remote_control:all` Tools [#tools] philips_hue_list_bridges [#philips_hue_list_bridges] Hue list bridges *No parameters.* philips_hue_list_lights [#philips_hue_list_lights] Hue list lights *No parameters.* philips_hue_get_light [#philips_hue_get_light] Hue get light philips_hue_update_light [#philips_hue_update_light] Hue update light philips_hue_list_rooms [#philips_hue_list_rooms] Hue list rooms *No parameters.* philips_hue_list_scenes [#philips_hue_list_scenes] Hue list scenes *No parameters.* Notes [#notes] * Category: Lifestyle * Authentication mode: OAuth # Pinterest Integration The Pinterest integration provides access to manage Pinterest boards, pins, search, ad accounts, and campaigns through the Integrate MCP server. Installation [#installation] The Pinterest integration is included with the SDK: ```typescript import { pinterestIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Pinterest OAuth App [#1-create-a-pinterest-oauth-app] 1. Create an OAuth application for Pinterest 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Pinterest integration to your server configuration. The integration automatically reads `PINTEREST_CLIENT_ID` and `PINTEREST_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, pinterestIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ pinterestIntegration({ scopes: ["boards:read", "boards:write", "pins:read", "pins:write", "user_accounts:read", "ads:read", "ads:write"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript pinterestIntegration({ clientId: process.env.CUSTOM_PINTEREST_ID, clientSecret: process.env.CUSTOM_PINTEREST_SECRET, scopes: ["boards:read", "boards:write", "pins:read", "pins:write", "user_accounts:read", "ads:read", "ads:write"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("pinterest"); const result = await client.pinterest.getUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, pinterestIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [pinterestIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `boards:read` * `boards:write` * `pins:read` * `pins:write` * `user_accounts:read` * `ads:read` * `ads:write` Tools [#tools] pinterest_get_user [#pinterest_get_user] Get user *No parameters.* pinterest_list_boards [#pinterest_list_boards] List boards pinterest_get_board [#pinterest_get_board] Get board pinterest_create_pin [#pinterest_create_pin] Create pin pinterest_get_pin [#pinterest_get_pin] Get pin pinterest_search_pins [#pinterest_search_pins] Search pins pinterest_list_ad_accounts [#pinterest_list_ad_accounts] List ad accounts pinterest_list_campaigns [#pinterest_list_campaigns] List campaigns Notes [#notes] * Category: Social Media * Authentication mode: OAuth # Pipedrive Integration The Pipedrive integration provides access to manage Pipedrive deals, leads, people, organizations, activities, notes, pipelines, and products through the Integrate MCP server. Installation [#installation] The Pipedrive integration is included with the SDK: ```typescript import { pipedriveIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Pipedrive OAuth App [#1-create-a-pipedrive-oauth-app] 1. Create an OAuth application for Pipedrive 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Pipedrive integration to your server configuration. The integration automatically reads `PIPEDRIVE_CLIENT_ID` and `PIPEDRIVE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, pipedriveIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ pipedriveIntegration({ scopes: ["deals:read", "deals:full", "contacts:read", "contacts:full", "activities:read", "activities:full", "products:read", "products:full"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript pipedriveIntegration({ clientId: process.env.CUSTOM_PIPEDRIVE_ID, clientSecret: process.env.CUSTOM_PIPEDRIVE_SECRET, scopes: ["deals:read", "deals:full", "contacts:read", "contacts:full", "activities:read", "activities:full", "products:read", "products:full"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("pipedrive"); const result = await client.pipedrive.listDeals({ api_domain: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, pipedriveIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [pipedriveIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `deals:read` * `deals:full` * `contacts:read` * `contacts:full` * `activities:read` * `activities:full` * `products:read` * `products:full` Tools [#tools] pipedrive_list_deals [#pipedrive_list_deals] List deals pipedrive_list_leads [#pipedrive_list_leads] List leads pipedrive_list_persons [#pipedrive_list_persons] List persons pipedrive_list_organizations [#pipedrive_list_organizations] List organizations pipedrive_list_activities [#pipedrive_list_activities] List activities pipedrive_list_notes [#pipedrive_list_notes] List notes pipedrive_list_pipelines [#pipedrive_list_pipelines] List pipelines pipedrive_list_products [#pipedrive_list_products] List products pipedrive_create_deal [#pipedrive_create_deal] Create deal Notes [#notes] * Category: Business * Authentication mode: OAuth # Plaid Integration The Plaid integration provides access to manage Plaid create link token, exchange public token, get accounts, get transactions, get identity through the Integrate MCP server. Installation [#installation] The Plaid integration is included with the SDK: ```typescript import { plaidIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Plaid OAuth App [#1-create-a-plaid-oauth-app] 1. Create an OAuth application for Plaid 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Plaid integration to your server configuration. The integration automatically reads `PLAID_CLIENT_ID` and `PLAID_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, plaidIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ plaidIntegration({ scopes: ["transactions", "auth", "identity", "accounts", "investments", "liabilities"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript plaidIntegration({ clientId: process.env.CUSTOM_PLAID_ID, clientSecret: process.env.CUSTOM_PLAID_SECRET, scopes: ["transactions", "auth", "identity", "accounts", "investments", "liabilities"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("plaid"); const result = await client.plaid.createLinkToken({ link_token_json: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, plaidIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [plaidIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `transactions` * `auth` * `identity` * `accounts` * `investments` * `liabilities` Tools [#tools] plaid_create_link_token [#plaid_create_link_token] Create link token plaid_exchange_public_token [#plaid_exchange_public_token] Exchange public token plaid_get_accounts [#plaid_get_accounts] Get accounts plaid_get_transactions [#plaid_get_transactions] Get transactions plaid_get_identity [#plaid_get_identity] Get identity plaid_get_investments [#plaid_get_investments] Get investments Notes [#notes] * Category: Banking * Authentication mode: OAuth # PlanetScale Integration The PlanetScale integration provides access to manage PlanetScale databases, branches, and schema changes through the Integrate MCP server. Installation [#installation] The PlanetScale integration is included with the SDK: ```typescript import { planetscaleIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a PlanetScale OAuth App [#1-create-a-planetscale-oauth-app] 1. Go to [Auth Developer Portal](https://auth.planetscale.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the PlanetScale integration to your server configuration. The integration automatically reads `PLANETSCALE_CLIENT_ID` and `PLANETSCALE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, planetscaleIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ planetscaleIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript planetscaleIntegration({ clientId: process.env.CUSTOM_PLANETSCALE_ID, clientSecret: process.env.CUSTOM_PLANETSCALE_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("planetscale"); // Use client.planetscale methods after connecting ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, planetscaleIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [planetscaleIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] planetscale_get_current_user [#planetscale_get_current_user] Get current user *No parameters.* planetscale_list_organizations [#planetscale_list_organizations] List organizations *No parameters.* planetscale_get_organization [#planetscale_get_organization] Get organization *No parameters.* planetscale_list_databases [#planetscale_list_databases] List databases *No parameters.* planetscale_get_database [#planetscale_get_database] Get database *No parameters.* planetscale_list_branches [#planetscale_list_branches] List branches *No parameters.* planetscale_get_branch [#planetscale_get_branch] Get branch *No parameters.* planetscale_list_deploy_requests [#planetscale_list_deploy_requests] List deploy requests *No parameters.* planetscale_get_deploy_request [#planetscale_get_deploy_request] Get deploy request *No parameters.* Notes [#notes] * Category: Infrastructure * Authentication mode: OAuth # Microsoft Planner Integration The Microsoft Planner integration provides access to manage Microsoft Planner plans, buckets, and tasks through the Integrate MCP server. Installation [#installation] The Microsoft Planner integration is included with the SDK: ```typescript import { plannerIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Microsoft Planner OAuth App [#1-create-a-microsoft-planner-oauth-app] 1. Go to [Azure Portal β€” App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Microsoft Planner integration to your server configuration. The integration automatically reads `PLANNER_CLIENT_ID` and `PLANNER_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, plannerIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ plannerIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript plannerIntegration({ clientId: process.env.CUSTOM_PLANNER_ID, clientSecret: process.env.CUSTOM_PLANNER_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("planner"); const result = await client.planner.createBucket({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, plannerIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [plannerIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] planner_create_bucket [#planner_create_bucket] Create bucket planner_create_plan [#planner_create_plan] Create plan planner_create_task [#planner_create_task] Create task planner_delete_task [#planner_delete_task] Delete task planner_get_plan [#planner_get_plan] Get plan planner_get_task [#planner_get_task] Get task planner_get_task_details [#planner_get_task_details] Get task details planner_list_buckets [#planner_list_buckets] List buckets planner_list_group_plans [#planner_list_group_plans] List group plans planner_list_my_plans [#planner_list_my_plans] List my plans planner_list_my_tasks [#planner_list_my_tasks] List my tasks planner_list_plan_tasks [#planner_list_plan_tasks] List plan tasks planner_update_task [#planner_update_task] Update task Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Polar Integration The Polar integration provides access to manage Polar products, orders, and subscriptions through the Integrate MCP server. Installation [#installation] The Polar integration is included with the SDK: ```typescript import { polarIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Polar OAuth App [#1-create-a-polar-oauth-app] 1. Go to [Polar Settings](https://polar.sh/settings) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Polar integration to your server configuration. The integration automatically reads `POLAR_CLIENT_ID` and `POLAR_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, polarIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ polarIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript polarIntegration({ clientId: process.env.CUSTOM_POLAR_ID, clientSecret: process.env.CUSTOM_POLAR_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("polar"); const result = await client.polar.listProducts({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, polarIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [polarIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] polar_list_products [#polar_list_products] List products polar_get_product [#polar_get_product] Get product details polar_create_product [#polar_create_product] Create a new product polar_update_product [#polar_update_product] Update a product polar_list_subscriptions [#polar_list_subscriptions] List subscriptions polar_get_subscription [#polar_get_subscription] Get subscription details polar_update_subscription [#polar_update_subscription] Update a subscription polar_revoke_subscription [#polar_revoke_subscription] Revoke a subscription polar_list_customers [#polar_list_customers] List customers polar_get_customer [#polar_get_customer] Get customer details polar_create_customer [#polar_create_customer] Create a new customer polar_update_customer [#polar_update_customer] Update a customer polar_delete_customer [#polar_delete_customer] Delete a customer polar_get_customer_state [#polar_get_customer_state] Get customer state (subscriptions, orders, etc.) polar_list_orders [#polar_list_orders] List orders polar_get_order [#polar_get_order] Get order details polar_get_order_invoice [#polar_get_order_invoice] Get order invoice polar_list_benefits [#polar_list_benefits] List benefits polar_get_benefit [#polar_get_benefit] Get benefit details polar_create_benefit [#polar_create_benefit] Create a new benefit polar_update_benefit [#polar_update_benefit] Update a benefit polar_list_discounts [#polar_list_discounts] List discounts polar_get_discount [#polar_get_discount] Get discount details polar_create_discount [#polar_create_discount] Create a new discount polar_delete_discount [#polar_delete_discount] Delete a discount polar_list_checkout_links [#polar_list_checkout_links] List checkout links polar_get_checkout_link [#polar_get_checkout_link] Get checkout link details polar_create_checkout_link [#polar_create_checkout_link] Create a new checkout link polar_list_license_keys [#polar_list_license_keys] List license keys polar_get_license_key [#polar_get_license_key] Get license key details polar_validate_license_key [#polar_validate_license_key] Validate a license key polar_activate_license_key [#polar_activate_license_key] Activate a license key polar_get_metrics [#polar_get_metrics] Get metrics for a time period polar_list_organizations [#polar_list_organizations] List organizations polar_get_organization [#polar_get_organization] Get organization details Notes [#notes] * Category: Finance * Authentication mode: OAuth # PostHog Integration The PostHog integration provides access to read PostHog organizations, projects, insights, flags, and analytics data through the Integrate MCP server. Installation [#installation] The PostHog integration is included with the SDK: ```typescript import { posthogIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a PostHog OAuth App [#1-create-a-posthog-oauth-app] 1. Create an OAuth application for PostHog 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the PostHog integration to your server configuration. The integration automatically reads `POSTHOG_CLIENT_ID` and `POSTHOG_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, posthogIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ posthogIntegration({ scopes: ["openid", "profile", "email", "organization:read", "project:read", "user:read", "query:read", "insight:read", "dashboard:read", "feature_flag:read", "experiment:read", "annotation:read", "cohort:read", "person:read", "event_definition:read", "property_definition:read", "session_recording:read", "action:read"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript posthogIntegration({ clientId: process.env.CUSTOM_POSTHOG_ID, clientSecret: process.env.CUSTOM_POSTHOG_SECRET, scopes: ["openid", "profile", "email", "organization:read", "project:read", "user:read", "query:read", "insight:read", "dashboard:read", "feature_flag:read", "experiment:read", "annotation:read", "cohort:read", "person:read", "event_definition:read", "property_definition:read", "session_recording:read", "action:read"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("posthog"); const result = await client.posthog.getCurrentUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, posthogIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [posthogIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `openid` * `profile` * `email` * `organization:read` * `project:read` * `user:read` * `query:read` * `insight:read` * `dashboard:read` * `feature_flag:read` * `experiment:read` * `annotation:read` * `cohort:read` * `person:read` * `event_definition:read` * `property_definition:read` * `session_recording:read` * `action:read` Tools [#tools] posthog_get_current_user [#posthog_get_current_user] Get current user *No parameters.* posthog_list_organizations [#posthog_list_organizations] List organizations posthog_get_organization [#posthog_get_organization] Get organization posthog_list_projects [#posthog_list_projects] List projects posthog_get_project [#posthog_get_project] Get project posthog_run_hogql_query [#posthog_run_hogql_query] Run hogql query posthog_list_insights [#posthog_list_insights] List insights posthog_get_insight [#posthog_get_insight] Get insight posthog_list_dashboards [#posthog_list_dashboards] List dashboards posthog_get_dashboard [#posthog_get_dashboard] Get dashboard posthog_list_feature_flags [#posthog_list_feature_flags] List feature flags posthog_get_feature_flag [#posthog_get_feature_flag] Get feature flag posthog_list_experiments [#posthog_list_experiments] List experiments posthog_get_experiment [#posthog_get_experiment] Get experiment posthog_list_annotations [#posthog_list_annotations] List annotations posthog_get_annotation [#posthog_get_annotation] Get annotation posthog_list_cohorts [#posthog_list_cohorts] List cohorts posthog_get_cohort [#posthog_get_cohort] Get cohort posthog_list_event_definitions [#posthog_list_event_definitions] List event definitions posthog_get_event_definition [#posthog_get_event_definition] Get event definition posthog_list_property_definitions [#posthog_list_property_definitions] List property definitions posthog_get_property_definition [#posthog_get_property_definition] Get property definition posthog_list_persons [#posthog_list_persons] List persons posthog_get_person [#posthog_get_person] Get person posthog_list_session_recordings [#posthog_list_session_recordings] List session recordings posthog_get_session_recording [#posthog_get_session_recording] Get session recording Notes [#notes] * Category: Analytics * Authentication mode: OAuth # Postman Integration The Postman integration provides access to manage Postman workspaces, collections, and environments via the Postman API through the Integrate MCP server. Installation [#installation] The Postman integration is included with the SDK: ```typescript import { postmanIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Postman to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, postmanIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ postmanIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.postman.getMe({}); console.log(result); ``` Environment Variables [#environment-variables] * `POSTMAN_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] postman_get_me [#postman_get_me] Get me *No parameters.* postman_list_workspaces [#postman_list_workspaces] List workspaces postman_get_workspace [#postman_get_workspace] Get workspace postman_list_collections [#postman_list_collections] List collections postman_get_collection [#postman_get_collection] Get collection postman_delete_collection [#postman_delete_collection] Delete collection postman_list_environments [#postman_list_environments] List environments postman_get_environment [#postman_get_environment] Get environment postman_create_collection [#postman_create_collection] Create collection Notes [#notes] * Category: Engineering * Authentication mode: API key # PowerPoint Integration The PowerPoint integration provides access to manage PowerPoint presentations and sharing through the Integrate MCP server. Installation [#installation] The PowerPoint integration is included with the SDK: ```typescript import { powerpointIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a PowerPoint OAuth App [#1-create-a-powerpoint-oauth-app] 1. Go to [Azure Portal β€” App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the PowerPoint integration to your server configuration. The integration automatically reads `POWERPOINT_CLIENT_ID` and `POWERPOINT_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, powerpointIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ powerpointIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript powerpointIntegration({ clientId: process.env.CUSTOM_POWERPOINT_ID, clientSecret: process.env.CUSTOM_POWERPOINT_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("powerpoint"); const result = await client.powerpoint.list({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, powerpointIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [powerpointIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] powerpoint_copy [#powerpoint_copy] Copy a presentation powerpoint_create [#powerpoint_create] Create a new empty .pptx file in OneDrive powerpoint_delete [#powerpoint_delete] Delete a presentation permanently powerpoint_get [#powerpoint_get] Get metadata for a presentation powerpoint_list [#powerpoint_list] Search for PowerPoint presentations powerpoint_share [#powerpoint_share] Create a sharing link for a presentation powerpoint_update_content [#powerpoint_update_content] Update content Notes [#notes] * Category: Productivity * Authentication mode: OAuth # QuickBooks Online Integration The QuickBooks Online integration provides access to manage QuickBooks Online company data, customers, vendors, items, accounts, invoices, bills, payments, reports, and queries through the Integrate MCP server. Installation [#installation] The QuickBooks Online integration is included with the SDK: ```typescript import { quickbooksIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a QuickBooks Online OAuth App [#1-create-a-quickbooks-online-oauth-app] 1. Create an OAuth application for QuickBooks Online 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the QuickBooks Online integration to your server configuration. The integration automatically reads `QUICKBOOKS_CLIENT_ID` and `QUICKBOOKS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, quickbooksIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ quickbooksIntegration({ scopes: ["com.intuit.quickbooks.accounting", "openid", "profile", "email", "offline_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript quickbooksIntegration({ clientId: process.env.CUSTOM_QUICKBOOKS_ID, clientSecret: process.env.CUSTOM_QUICKBOOKS_SECRET, scopes: ["com.intuit.quickbooks.accounting", "openid", "profile", "email", "offline_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("quickbooks"); const result = await client.quickbooks.getCompanyInfo({ company_id: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, quickbooksIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [quickbooksIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `com.intuit.quickbooks.accounting` * `openid` * `profile` * `email` * `offline_access` Tools [#tools] quickbooks_get_company_info [#quickbooks_get_company_info] Get company info quickbooks_query [#quickbooks_query] Query quickbooks_list_customers [#quickbooks_list_customers] List customers quickbooks_get_customer [#quickbooks_get_customer] Get customer quickbooks_create_customer [#quickbooks_create_customer] Create customer quickbooks_list_vendors [#quickbooks_list_vendors] List vendors quickbooks_create_vendor [#quickbooks_create_vendor] Create vendor quickbooks_list_items [#quickbooks_list_items] List items quickbooks_create_item [#quickbooks_create_item] Create item quickbooks_list_accounts [#quickbooks_list_accounts] List accounts quickbooks_list_invoices [#quickbooks_list_invoices] List invoices quickbooks_get_invoice [#quickbooks_get_invoice] Get invoice quickbooks_create_invoice [#quickbooks_create_invoice] Create invoice quickbooks_list_bills [#quickbooks_list_bills] List bills quickbooks_create_bill [#quickbooks_create_bill] Create bill quickbooks_create_payment [#quickbooks_create_payment] Create payment quickbooks_get_report [#quickbooks_get_report] Get report Notes [#notes] * Category: Accounting * Authentication mode: OAuth # Railway Integration The Railway integration provides access to manage Railway workspaces, projects, services, deployments, variables, domains, and volumes through the Integrate MCP server. Installation [#installation] The Railway integration is included with the SDK: ```typescript import { railwayIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Railway OAuth App [#1-create-a-railway-oauth-app] 1. Go to [Backboard Developer Portal](https://backboard.railway.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Railway integration to your server configuration. The integration automatically reads `RAILWAY_CLIENT_ID` and `RAILWAY_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, railwayIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ railwayIntegration({ scopes: ["openid", "profile", "email", "workspace:admin", "project:member"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript railwayIntegration({ clientId: process.env.CUSTOM_RAILWAY_ID, clientSecret: process.env.CUSTOM_RAILWAY_SECRET, scopes: ["openid", "profile", "email", "workspace:admin", "project:member"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("railway"); const result = await client.railway.getCurrentUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, railwayIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [railwayIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `openid` * `profile` * `email` * `workspace:admin` * `project:member` Tools [#tools] railway_get_current_user [#railway_get_current_user] Get current user *No parameters.* railway_get_workspace [#railway_get_workspace] Get workspace railway_list_regions [#railway_list_regions] List regions *No parameters.* railway_list_projects [#railway_list_projects] List projects railway_get_project [#railway_get_project] Get project railway_create_project [#railway_create_project] Create project railway_update_project [#railway_update_project] Update project railway_delete_project [#railway_delete_project] Delete project railway_transfer_project [#railway_transfer_project] Transfer project railway_list_project_members [#railway_list_project_members] List project members railway_list_environments [#railway_list_environments] List environments railway_get_environment [#railway_get_environment] Get environment railway_create_environment [#railway_create_environment] Create environment railway_rename_environment [#railway_rename_environment] Rename environment railway_delete_environment [#railway_delete_environment] Delete environment railway_get_environment_logs [#railway_get_environment_logs] Get environment logs railway_get_environment_staged_changes [#railway_get_environment_staged_changes] Get environment staged changes railway_commit_environment_staged_changes [#railway_commit_environment_staged_changes] Commit environment staged changes railway_get_service [#railway_get_service] Get service railway_get_service_instance [#railway_get_service_instance] Get service instance railway_create_service [#railway_create_service] Create service railway_update_service [#railway_update_service] Update service railway_update_service_instance [#railway_update_service_instance] Update service instance railway_connect_service [#railway_connect_service] Connect service railway_disconnect_service [#railway_disconnect_service] Disconnect service railway_deploy_service [#railway_deploy_service] Deploy service railway_redeploy_service [#railway_redeploy_service] Redeploy service railway_get_service_limits [#railway_get_service_limits] Get service limits railway_delete_service [#railway_delete_service] Delete service railway_list_deployments [#railway_list_deployments] List deployments railway_get_deployment [#railway_get_deployment] Get deployment railway_get_latest_active_deployment [#railway_get_latest_active_deployment] Get latest active deployment railway_get_deployment_build_logs [#railway_get_deployment_build_logs] Get deployment build logs railway_get_deployment_runtime_logs [#railway_get_deployment_runtime_logs] Get deployment runtime logs railway_get_deployment_http_logs [#railway_get_deployment_http_logs] Get deployment http logs railway_redeploy_deployment [#railway_redeploy_deployment] Redeploy deployment railway_restart_deployment [#railway_restart_deployment] Restart deployment railway_rollback_deployment [#railway_rollback_deployment] Rollback deployment railway_stop_deployment [#railway_stop_deployment] Stop deployment railway_cancel_deployment [#railway_cancel_deployment] Cancel deployment railway_remove_deployment [#railway_remove_deployment] Remove deployment railway_get_variables [#railway_get_variables] Get variables railway_get_unrendered_variables [#railway_get_unrendered_variables] Get unrendered variables railway_upsert_variable [#railway_upsert_variable] Upsert variable railway_upsert_variables [#railway_upsert_variables] Upsert variables railway_delete_variable [#railway_delete_variable] Delete variable railway_get_rendered_variables [#railway_get_rendered_variables] Get rendered variables railway_list_domains [#railway_list_domains] List domains railway_create_service_domain [#railway_create_service_domain] Create service domain railway_delete_service_domain [#railway_delete_service_domain] Delete service domain railway_check_custom_domain_availability [#railway_check_custom_domain_availability] Check custom domain availability railway_create_custom_domain [#railway_create_custom_domain] Create custom domain railway_get_custom_domain_status [#railway_get_custom_domain_status] Get custom domain status railway_update_custom_domain [#railway_update_custom_domain] Update custom domain railway_delete_custom_domain [#railway_delete_custom_domain] Delete custom domain railway_list_project_volumes [#railway_list_project_volumes] List project volumes railway_get_volume_instance [#railway_get_volume_instance] Get volume instance railway_create_volume [#railway_create_volume] Create volume railway_update_volume [#railway_update_volume] Update volume railway_update_volume_instance [#railway_update_volume_instance] Update volume instance railway_delete_volume [#railway_delete_volume] Delete volume railway_list_volume_backups [#railway_list_volume_backups] List volume backups railway_create_volume_backup [#railway_create_volume_backup] Create volume backup railway_restore_volume_backup [#railway_restore_volume_backup] Restore volume backup railway_lock_volume_backup [#railway_lock_volume_backup] Lock volume backup railway_delete_volume_backup [#railway_delete_volume_backup] Delete volume backup railway_list_volume_backup_schedules [#railway_list_volume_backup_schedules] List volume backup schedules railway_list_tcp_proxies [#railway_list_tcp_proxies] List tcp proxies Notes [#notes] * Category: Infrastructure * Authentication mode: OAuth # Ramp Integration The Ramp integration provides access to manage Ramp corporate cards, bills, reimbursements, and spend controls through the Integrate MCP server. Installation [#installation] The Ramp integration is included with the SDK: ```typescript import { rampIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Ramp OAuth App [#1-create-a-ramp-oauth-app] 1. Go to [Ramp Developer Portal](https://app.ramp.com/developer) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Ramp integration to your server configuration. The integration automatically reads `RAMP_CLIENT_ID` and `RAMP_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, rampIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ rampIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript rampIntegration({ clientId: process.env.CUSTOM_RAMP_ID, clientSecret: process.env.CUSTOM_RAMP_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("ramp"); const result = await client.ramp.listTransactions({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, rampIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [rampIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] ramp_list_transactions [#ramp_list_transactions] List transactions ramp_get_transaction [#ramp_get_transaction] Get transaction details ramp_list_cards [#ramp_list_cards] List cards ramp_get_card [#ramp_get_card] Get card details ramp_list_users [#ramp_list_users] List users ramp_get_user [#ramp_get_user] Get user details ramp_list_departments [#ramp_list_departments] List departments ramp_list_reimbursements [#ramp_list_reimbursements] List reimbursements ramp_get_spend_limits [#ramp_get_spend_limits] Get spend limits Notes [#notes] * Category: Finance * Authentication mode: OAuth # Reddit Integration The Reddit integration provides access to browse subreddits, search posts, submit content, and vote on Reddit through the Integrate MCP server. Installation [#installation] The Reddit integration is included with the SDK: ```typescript import { redditIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Reddit OAuth App [#1-create-a-reddit-oauth-app] 1. Create an OAuth application for Reddit 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Reddit integration to your server configuration. The integration automatically reads `REDDIT_CLIENT_ID` and `REDDIT_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, redditIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ redditIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript redditIntegration({ clientId: process.env.CUSTOM_REDDIT_ID, clientSecret: process.env.CUSTOM_REDDIT_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("reddit"); // Use client.reddit methods after connecting ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, redditIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [redditIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] reddit_get_me [#reddit_get_me] Get me *No parameters.* reddit_get_subreddit_about [#reddit_get_subreddit_about] Get subreddit about *No parameters.* reddit_list_subreddit_posts [#reddit_list_subreddit_posts] List subreddit posts *No parameters.* reddit_get_post_thread [#reddit_get_post_thread] Get post thread *No parameters.* reddit_search [#reddit_search] Search *No parameters.* reddit_submit_post [#reddit_submit_post] Submit post *No parameters.* reddit_comment [#reddit_comment] Comment *No parameters.* reddit_vote [#reddit_vote] Vote *No parameters.* reddit_list_my_subreddits [#reddit_list_my_subreddits] List my subreddits *No parameters.* reddit_list_popular_subreddits [#reddit_list_popular_subreddits] List popular subreddits *No parameters.* Notes [#notes] * Category: Social Media * Authentication mode: OAuth # Redis Cloud Integration The Redis Cloud integration provides access to manage Redis Cloud subscriptions, databases, async tasks, and audit logs via the REST API through the Integrate MCP server. Installation [#installation] The Redis Cloud integration is included with the SDK: ```typescript import { redisIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Redis Cloud to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, redisIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ redisIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.redis.listSubscriptions({}); console.log(result); ``` Environment Variables [#environment-variables] * `REDIS_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] redis_list_subscriptions [#redis_list_subscriptions] List subscriptions *No parameters.* redis_get_subscription [#redis_get_subscription] Get subscription redis_list_fixed_subscriptions [#redis_list_fixed_subscriptions] List fixed subscriptions *No parameters.* redis_get_fixed_subscription [#redis_get_fixed_subscription] Get fixed subscription redis_list_databases [#redis_list_databases] List databases redis_get_database [#redis_get_database] Get database redis_create_database [#redis_create_database] Create database redis_update_database [#redis_update_database] Update database redis_delete_database [#redis_delete_database] Delete database redis_list_essentials_databases [#redis_list_essentials_databases] List essentials databases redis_get_essentials_database [#redis_get_essentials_database] Get essentials database redis_create_essentials_database [#redis_create_essentials_database] Create essentials database redis_update_essentials_database [#redis_update_essentials_database] Update essentials database redis_delete_essentials_database [#redis_delete_essentials_database] Delete essentials database redis_get_task [#redis_get_task] Get task redis_list_logs [#redis_list_logs] List logs Notes [#notes] * Category: Infrastructure * Authentication mode: API key # Resend Integration The Resend integration provides access to send email and manage domains with the Resend API through the Integrate MCP server. Installation [#installation] The Resend integration is included with the SDK: ```typescript import { resendIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Resend to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, resendIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ resendIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; // Use client.resend methods after connecting ``` Environment Variables [#environment-variables] * `RESEND_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] resend_list_domains [#resend_list_domains] List domains *No parameters.* resend_get_domain [#resend_get_domain] Get domain *No parameters.* resend_create_domain [#resend_create_domain] Create domain *No parameters.* resend_delete_domain [#resend_delete_domain] Delete domain *No parameters.* resend_verify_domain [#resend_verify_domain] Verify domain *No parameters.* resend_send_email [#resend_send_email] Send email *No parameters.* resend_get_email [#resend_get_email] Get email *No parameters.* resend_cancel_scheduled_email [#resend_cancel_scheduled_email] Cancel scheduled email *No parameters.* Notes [#notes] * Category: Communication * Authentication mode: API key # Ring Integration The Ring integration provides access to manage Ring list locations, list devices, get device health, list events, activate siren through the Integrate MCP server. Installation [#installation] The Ring integration is included with the SDK: ```typescript import { ringIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Ring OAuth App [#1-create-a-ring-oauth-app] 1. Create an OAuth application for Ring 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Ring integration to your server configuration. The integration automatically reads `RING_CLIENT_ID` and `RING_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, ringIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ ringIntegration({ scopes: ["openid", "profile", "offline_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript ringIntegration({ clientId: process.env.CUSTOM_RING_ID, clientSecret: process.env.CUSTOM_RING_SECRET, scopes: ["openid", "profile", "offline_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("ring"); const result = await client.ring.listLocations({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, ringIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [ringIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `openid` * `profile` * `offline_access` Tools [#tools] ring_list_locations [#ring_list_locations] List locations *No parameters.* ring_list_devices [#ring_list_devices] List devices ring_get_device_health [#ring_get_device_health] Get device health ring_list_events [#ring_list_events] List events ring_activate_siren [#ring_activate_siren] Activate siren Notes [#notes] * Category: Lifestyle * Authentication mode: OAuth # Sage Integration The Sage integration provides access to manage Sage business details, contacts, products, and sales invoices through the Integrate MCP server. Installation [#installation] The Sage integration is included with the SDK: ```typescript import { sageIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Sage OAuth App [#1-create-a-sage-oauth-app] 1. Create an OAuth application for Sage 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Sage integration to your server configuration. The integration automatically reads `SAGE_CLIENT_ID` and `SAGE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, sageIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ sageIntegration({ scopes: ["full_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript sageIntegration({ clientId: process.env.CUSTOM_SAGE_ID, clientSecret: process.env.CUSTOM_SAGE_SECRET, scopes: ["full_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("sage"); const result = await client.sage.getBusiness({ business_id: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, sageIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [sageIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `full_access` Tools [#tools] sage_get_business [#sage_get_business] Get business sage_list_contacts [#sage_list_contacts] List contacts sage_create_contact [#sage_create_contact] Create contact sage_list_products [#sage_list_products] List products sage_list_sales_invoices [#sage_list_sales_invoices] List sales invoices sage_create_sales_invoice [#sage_create_sales_invoice] Create sales invoice Notes [#notes] * Category: Accounting * Authentication mode: OAuth # Salesforce Integration The Salesforce integration provides access to manage Salesforce accounts, contacts, opportunities, and cases through the Integrate MCP server. Installation [#installation] The Salesforce integration is included with the SDK: ```typescript import { salesforceIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Salesforce OAuth App [#1-create-a-salesforce-oauth-app] 1. Create an OAuth application for Salesforce 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Salesforce integration to your server configuration. The integration automatically reads `SALESFORCE_CLIENT_ID` and `SALESFORCE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, salesforceIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ salesforceIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript salesforceIntegration({ clientId: process.env.CUSTOM_SALESFORCE_ID, clientSecret: process.env.CUSTOM_SALESFORCE_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("salesforce"); const result = await client.salesforce.query({ q: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, salesforceIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [salesforceIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] salesforce_query [#salesforce_query] Query salesforce_get_limits [#salesforce_get_limits] Get limits salesforce_describe_global [#salesforce_describe_global] Describe global salesforce_sobject_describe [#salesforce_sobject_describe] Sobject describe salesforce_sobject_get [#salesforce_sobject_get] Sobject get salesforce_sobject_create [#salesforce_sobject_create] Sobject create salesforce_sobject_update [#salesforce_sobject_update] Sobject update salesforce_sobject_delete [#salesforce_sobject_delete] Sobject delete Notes [#notes] * Category: Business * Authentication mode: OAuth # Sentry Integration The Sentry integration provides access to monitor Sentry errors, issues, releases, and projects through the Integrate MCP server. Installation [#installation] The Sentry integration is included with the SDK: ```typescript import { sentryIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Sentry OAuth App [#1-create-a-sentry-oauth-app] 1. Go to [Sentry Developer Portal](https://sentry.io) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Sentry integration to your server configuration. The integration automatically reads `SENTRY_CLIENT_ID` and `SENTRY_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, sentryIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ sentryIntegration({ scopes: ["org:read", "project:read", "team:read", "member:read", "event:read", "event:write", "project:releases"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript sentryIntegration({ clientId: process.env.CUSTOM_SENTRY_ID, clientSecret: process.env.CUSTOM_SENTRY_SECRET, scopes: ["org:read", "project:read", "team:read", "member:read", "event:read", "event:write", "project:releases"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("sentry"); const result = await client.sentry.getOrganization({ org_slug: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, sentryIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [sentryIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `org:read` * `project:read` * `team:read` * `member:read` * `event:read` * `event:write` * `project:releases` Tools [#tools] sentry_get_organization [#sentry_get_organization] Get organization sentry_list_org_projects [#sentry_list_org_projects] List org projects sentry_list_org_members [#sentry_list_org_members] List org members sentry_get_project [#sentry_get_project] Get project sentry_list_issues [#sentry_list_issues] List issues sentry_get_issue [#sentry_get_issue] Get issue sentry_update_issue [#sentry_update_issue] Update issue sentry_list_issue_events [#sentry_list_issue_events] List issue events sentry_list_project_events [#sentry_list_project_events] List project events sentry_list_releases [#sentry_list_releases] List releases sentry_get_release [#sentry_get_release] Get release sentry_create_release [#sentry_create_release] Create release sentry_list_release_commits [#sentry_list_release_commits] List release commits sentry_resolve_short_id [#sentry_resolve_short_id] Resolve short id Notes [#notes] * Category: Engineering * Authentication mode: OAuth # SharePoint Integration The SharePoint integration provides access to search SharePoint sites and manage drives, files, folders, and sharing links through the Integrate MCP server. Installation [#installation] The SharePoint integration is included with the SDK: ```typescript import { sharepointIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a SharePoint OAuth App [#1-create-a-sharepoint-oauth-app] 1. Go to [Azure Portal β€” App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the SharePoint integration to your server configuration. The integration automatically reads `SHAREPOINT_CLIENT_ID` and `SHAREPOINT_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, sharepointIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ sharepointIntegration({ scopes: ["Sites.ReadWrite.All", "Files.ReadWrite.All", "offline_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript sharepointIntegration({ clientId: process.env.CUSTOM_SHAREPOINT_ID, clientSecret: process.env.CUSTOM_SHAREPOINT_SECRET, scopes: ["Sites.ReadWrite.All", "Files.ReadWrite.All", "offline_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("sharepoint"); const result = await client.sharepoint.createFolder({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, sharepointIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [sharepointIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `Sites.ReadWrite.All` * `Files.ReadWrite.All` * `offline_access` Tools [#tools] sharepoint_create_folder [#sharepoint_create_folder] Create folder sharepoint_delete_item [#sharepoint_delete_item] Delete item sharepoint_get_item [#sharepoint_get_item] Get item sharepoint_get_site [#sharepoint_get_site] Get site sharepoint_list_drives [#sharepoint_list_drives] List drives sharepoint_list_items [#sharepoint_list_items] List items sharepoint_search_files [#sharepoint_search_files] Search files sharepoint_search_sites [#sharepoint_search_sites] Search sites sharepoint_share_item [#sharepoint_share_item] Share item sharepoint_update_item [#sharepoint_update_item] Update item sharepoint_upload_file [#sharepoint_upload_file] Upload file Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Shopify Integration The Shopify integration provides access to route-complete Shopify Admin access through GraphQL and REST tools through the Integrate MCP server. Installation [#installation] The Shopify integration is included with the SDK: ```typescript import { shopifyIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Shopify OAuth App [#1-create-a-shopify-oauth-app] 1. Go to [Shopify Developer Portal](https://shopify.oauth.placeholder) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Shopify integration to your server configuration. The integration automatically reads `SHOPIFY_CLIENT_ID` and `SHOPIFY_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, shopifyIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ shopifyIntegration({ scopes: ["read_products", "write_products", "read_orders", "write_orders", "read_customers", "write_customers", "read_inventory", "write_inventory", "read_content", "write_content", "read_fulfillments", "write_fulfillments", "read_analytics"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript shopifyIntegration({ clientId: process.env.CUSTOM_SHOPIFY_ID, clientSecret: process.env.CUSTOM_SHOPIFY_SECRET, scopes: ["read_products", "write_products", "read_orders", "write_orders", "read_customers", "write_customers", "read_inventory", "write_inventory", "read_content", "write_content", "read_fulfillments", "write_fulfillments", "read_analytics"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("shopify"); const result = await client.shopify.adminGraphql({ query: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, shopifyIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [shopifyIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `read_products` * `write_products` * `read_orders` * `write_orders` * `read_customers` * `write_customers` * `read_inventory` * `write_inventory` * `read_content` * `write_content` * `read_fulfillments` * `write_fulfillments` * `read_analytics` Tools [#tools] shopify_admin_graphql [#shopify_admin_graphql] Admin graphql shopify_rest_get [#shopify_rest_get] Rest get shopify_rest_post [#shopify_rest_post] Rest post shopify_rest_put [#shopify_rest_put] Rest put shopify_rest_delete [#shopify_rest_delete] Rest delete shopify_get_shop [#shopify_get_shop] Get shop Notes [#notes] * Category: Commerce * Authentication mode: OAuth # Slack Integration The Slack integration provides access to send and manage Slack messages and channels through the Integrate MCP server. Installation [#installation] The Slack integration is included with the SDK: ```typescript import { slackIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Slack OAuth App [#1-create-a-slack-oauth-app] 1. Go to [Slack API Apps](https://api.slack.com/apps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Slack integration to your server configuration. The integration automatically reads `SLACK_CLIENT_ID` and `SLACK_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, slackIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ slackIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript slackIntegration({ clientId: process.env.CUSTOM_SLACK_ID, clientSecret: process.env.CUSTOM_SLACK_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("slack"); const result = await client.slack.sendMessage({ channel: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, slackIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [slackIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] slack_send_message [#slack_send_message] Send a message to a Slack channel slack_list_messages [#slack_list_messages] Get message history from a channel slack_get_thread_replies [#slack_get_thread_replies] Get all replies in a message thread slack_update_message [#slack_update_message] Update the text of an existing message slack_delete_message [#slack_delete_message] Delete a message slack_schedule_message [#slack_schedule_message] Schedule a message to be sent at a future time slack_get_permalink [#slack_get_permalink] Get a permanent URL for a specific message slack_search_messages [#slack_search_messages] Search for messages across the workspace slack_list_channels [#slack_list_channels] List channels in the workspace slack_get_channel [#slack_get_channel] Get details about a specific channel slack_create_channel [#slack_create_channel] Create a new channel slack_invite_to_channel [#slack_invite_to_channel] Invite one or more users to a channel slack_list_channel_members [#slack_list_channel_members] List all members of a channel slack_set_channel_topic [#slack_set_channel_topic] Set the topic of a channel slack_archive_channel [#slack_archive_channel] Archive a channel slack_list_users [#slack_list_users] List all users in the workspace slack_get_user [#slack_get_user] Get detailed profile for a user slack_lookup_user_by_email [#slack_lookup_user_by_email] Find a user by their email address slack_add_reaction [#slack_add_reaction] Add an emoji reaction to a message slack_remove_reaction [#slack_remove_reaction] Remove an emoji reaction from a message slack_get_reactions [#slack_get_reactions] Get all reactions on a message slack_upload_file [#slack_upload_file] Upload a text file to one or more channels slack_pin_message [#slack_pin_message] Pin a message in a channel slack_unpin_message [#slack_unpin_message] Unpin a message in a channel slack_list_pins [#slack_list_pins] List all pinned items in a channel slack_set_channel_purpose [#slack_set_channel_purpose] Set the purpose of a channel slack_rename_channel [#slack_rename_channel] Rename a channel slack_join_channel [#slack_join_channel] Join a channel slack_leave_channel [#slack_leave_channel] Leave a channel slack_kick_from_channel [#slack_kick_from_channel] Remove a user from a channel slack_unarchive_channel [#slack_unarchive_channel] Unarchive a channel slack_open_dm [#slack_open_dm] Open or resume a direct message conversation with one or more users slack_get_user_presence [#slack_get_user_presence] Get the presence status of a user slack_get_dnd_info [#slack_get_dnd_info] Get Do Not Disturb status for a user slack_list_files [#slack_list_files] List files in the workspace slack_get_file [#slack_get_file] Get info about a file slack_delete_file [#slack_delete_file] Delete a file slack_get_team_info [#slack_get_team_info] Get information about the current workspace/team *No parameters.* slack_list_bookmarks [#slack_list_bookmarks] List bookmarks for a channel slack_add_bookmark [#slack_add_bookmark] Add a bookmark to a channel slack_list_reminders [#slack_list_reminders] List reminders for the authenticated user *No parameters.* slack_add_reminder [#slack_add_reminder] Create a reminder for the authenticated user slack_list_usergroups [#slack_list_usergroups] List user groups in the workspace Notes [#notes] * Category: Communication * Authentication mode: OAuth # Smartsheet Integration The Smartsheet integration provides access to manage Smartsheet sheets, rows, columns, workspaces, reports, and attachments through the Integrate MCP server. Installation [#installation] The Smartsheet integration is included with the SDK: ```typescript import { smartsheetIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Smartsheet OAuth App [#1-create-a-smartsheet-oauth-app] 1. Create an OAuth application for Smartsheet 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Smartsheet integration to your server configuration. The integration automatically reads `SMARTSHEET_CLIENT_ID` and `SMARTSHEET_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, smartsheetIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ smartsheetIntegration({ scopes: ["READ_SHEETS", "WRITE_SHEETS", "ADMIN_SHEETS", "READ_USERS", "READ_WORKSPACES", "ADMIN_WORKSPACES"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript smartsheetIntegration({ clientId: process.env.CUSTOM_SMARTSHEET_ID, clientSecret: process.env.CUSTOM_SMARTSHEET_SECRET, scopes: ["READ_SHEETS", "WRITE_SHEETS", "ADMIN_SHEETS", "READ_USERS", "READ_WORKSPACES", "ADMIN_WORKSPACES"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("smartsheet"); const result = await client.smartsheet.listSheets({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, smartsheetIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [smartsheetIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `READ_SHEETS` * `WRITE_SHEETS` * `ADMIN_SHEETS` * `READ_USERS` * `READ_WORKSPACES` * `ADMIN_WORKSPACES` Tools [#tools] smartsheet_list_sheets [#smartsheet_list_sheets] List sheets smartsheet_get_sheet [#smartsheet_get_sheet] Get sheet smartsheet_create_sheet [#smartsheet_create_sheet] Create sheet smartsheet_add_rows [#smartsheet_add_rows] Add rows smartsheet_update_rows [#smartsheet_update_rows] Update rows smartsheet_list_workspaces [#smartsheet_list_workspaces] List workspaces smartsheet_list_reports [#smartsheet_list_reports] List reports smartsheet_list_attachments [#smartsheet_list_attachments] List attachments Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Samsung SmartThings Integration The Samsung SmartThings integration provides access to manage SmartThings locations, rooms, devices, commands, scenes, and rules through the Integrate MCP server. Installation [#installation] The Samsung SmartThings integration is included with the SDK: ```typescript import { smartthingsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Samsung SmartThings OAuth App [#1-create-a-samsung-smartthings-oauth-app] 1. Create an OAuth application for Samsung SmartThings 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Samsung SmartThings integration to your server configuration. The integration automatically reads `SMARTTHINGS_CLIENT_ID` and `SMARTTHINGS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, smartthingsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ smartthingsIntegration({ scopes: ["r:locations:*", "x:locations:*", "r:devices:*", "x:devices:*", "r:scenes:*", "x:scenes:*", "r:rules:*", "x:rules:*"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript smartthingsIntegration({ clientId: process.env.CUSTOM_SMARTTHINGS_ID, clientSecret: process.env.CUSTOM_SMARTTHINGS_SECRET, scopes: ["r:locations:*", "x:locations:*", "r:devices:*", "x:devices:*", "r:scenes:*", "x:scenes:*", "r:rules:*", "x:rules:*"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("smartthings"); const result = await client.smartthings.listLocations({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, smartthingsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [smartthingsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `r:locations:*` * `x:locations:*` * `r:devices:*` * `x:devices:*` * `r:scenes:*` * `x:scenes:*` * `r:rules:*` * `x:rules:*` Tools [#tools] smartthings_list_locations [#smartthings_list_locations] List locations *No parameters.* smartthings_get_location [#smartthings_get_location] Get location smartthings_list_rooms [#smartthings_list_rooms] List rooms smartthings_get_room [#smartthings_get_room] Get room smartthings_list_devices [#smartthings_list_devices] List devices smartthings_get_device [#smartthings_get_device] Get device smartthings_get_device_status [#smartthings_get_device_status] Get device status smartthings_execute_device_command [#smartthings_execute_device_command] Execute device command smartthings_list_scenes [#smartthings_list_scenes] List scenes smartthings_execute_scene [#smartthings_execute_scene] Execute scene smartthings_list_rules [#smartthings_list_rules] List rules smartthings_get_rule [#smartthings_get_rule] Get rule smartthings_create_rule [#smartthings_create_rule] Create rule smartthings_update_rule [#smartthings_update_rule] Update rule smartthings_delete_rule [#smartthings_delete_rule] Delete rule Notes [#notes] * Category: Lifestyle * Authentication mode: OAuth # Snowflake Integration The Snowflake integration provides access to manage Snowflake submit statement, get statement, cancel statement, list databases, list warehouses through the Integrate MCP server. Installation [#installation] The Snowflake integration is included with the SDK: ```typescript import { snowflakeIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Snowflake OAuth App [#1-create-a-snowflake-oauth-app] 1. Create an OAuth application for Snowflake 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Snowflake integration to your server configuration. The integration automatically reads `SNOWFLAKE_CLIENT_ID` and `SNOWFLAKE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, snowflakeIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ snowflakeIntegration({ scopes: ["session:role-any"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript snowflakeIntegration({ clientId: process.env.CUSTOM_SNOWFLAKE_ID, clientSecret: process.env.CUSTOM_SNOWFLAKE_SECRET, scopes: ["session:role-any"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("snowflake"); const result = await client.snowflake.submitStatement({ statement_json: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, snowflakeIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [snowflakeIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `session:role-any` Tools [#tools] snowflake_submit_statement [#snowflake_submit_statement] Submit statement snowflake_get_statement [#snowflake_get_statement] Get statement snowflake_cancel_statement [#snowflake_cancel_statement] Cancel statement snowflake_list_databases [#snowflake_list_databases] List databases snowflake_list_warehouses [#snowflake_list_warehouses] List warehouses Notes [#notes] * Category: Data & BI * Authentication mode: OAuth # Sonos Integration The Sonos integration provides access to manage Sonos list households, list groups, get playback status, control playback, get group volume through the Integrate MCP server. Installation [#installation] The Sonos integration is included with the SDK: ```typescript import { sonosIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Sonos OAuth App [#1-create-a-sonos-oauth-app] 1. Create an OAuth application for Sonos 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Sonos integration to your server configuration. The integration automatically reads `SONOS_CLIENT_ID` and `SONOS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, sonosIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ sonosIntegration({ scopes: ["playback-control-all"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript sonosIntegration({ clientId: process.env.CUSTOM_SONOS_ID, clientSecret: process.env.CUSTOM_SONOS_SECRET, scopes: ["playback-control-all"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("sonos"); const result = await client.sonos.listHouseholds({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, sonosIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [sonosIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `playback-control-all` Tools [#tools] sonos_list_households [#sonos_list_households] List households *No parameters.* sonos_list_groups [#sonos_list_groups] List groups sonos_get_playback_status [#sonos_get_playback_status] Get playback status sonos_control_playback [#sonos_control_playback] Control playback sonos_get_group_volume [#sonos_get_group_volume] Get group volume sonos_set_group_volume [#sonos_set_group_volume] Set group volume Notes [#notes] * Category: Lifestyle * Authentication mode: OAuth # Spotify Integration The Spotify integration provides access to search Spotify, manage playlists and saved tracks, and control playback through the Integrate MCP server. Installation [#installation] The Spotify integration is included with the SDK: ```typescript import { spotifyIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Spotify OAuth App [#1-create-a-spotify-oauth-app] 1. Create an OAuth application for Spotify 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Spotify integration to your server configuration. The integration automatically reads `SPOTIFY_CLIENT_ID` and `SPOTIFY_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, spotifyIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ spotifyIntegration({ scopes: ["user-read-email", "playlist-read-private", "playlist-modify-private", "playlist-modify-public", "user-library-read", "user-library-modify", "user-read-playback-state", "user-modify-playback-state"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript spotifyIntegration({ clientId: process.env.CUSTOM_SPOTIFY_ID, clientSecret: process.env.CUSTOM_SPOTIFY_SECRET, scopes: ["user-read-email", "playlist-read-private", "playlist-modify-private", "playlist-modify-public", "user-library-read", "user-library-modify", "user-read-playback-state", "user-modify-playback-state"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("spotify"); const result = await client.spotify.getCurrentUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, spotifyIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [spotifyIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `user-read-email` * `playlist-read-private` * `playlist-modify-private` * `playlist-modify-public` * `user-library-read` * `user-library-modify` * `user-read-playback-state` * `user-modify-playback-state` Tools [#tools] spotify_get_current_user [#spotify_get_current_user] Get current user *No parameters.* spotify_search [#spotify_search] Search spotify_get_track [#spotify_get_track] Get track spotify_get_album [#spotify_get_album] Get album spotify_list_user_playlists [#spotify_list_user_playlists] List user playlists spotify_get_playlist [#spotify_get_playlist] Get playlist spotify_create_playlist [#spotify_create_playlist] Create playlist spotify_add_playlist_items [#spotify_add_playlist_items] Add playlist items spotify_remove_playlist_items [#spotify_remove_playlist_items] Remove playlist items spotify_get_saved_tracks [#spotify_get_saved_tracks] Get saved tracks spotify_save_tracks [#spotify_save_tracks] Save tracks spotify_remove_saved_tracks [#spotify_remove_saved_tracks] Remove saved tracks spotify_get_playback_state [#spotify_get_playback_state] Get playback state spotify_start_playback [#spotify_start_playback] Start playback spotify_pause_playback [#spotify_pause_playback] Pause playback Notes [#notes] * Category: Entertainment * Authentication mode: OAuth # Square Integration The Square integration provides access to manage Square merchants, locations, customers, catalog, orders, payments, refunds, and invoices through the Integrate MCP server. Installation [#installation] The Square integration is included with the SDK: ```typescript import { squareIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Square OAuth App [#1-create-a-square-oauth-app] 1. Create an OAuth application for Square 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Square integration to your server configuration. The integration automatically reads `SQUARE_CLIENT_ID` and `SQUARE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, squareIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ squareIntegration({ scopes: ["MERCHANT_PROFILE_READ", "PAYMENTS_READ", "PAYMENTS_WRITE", "CUSTOMERS_READ", "CUSTOMERS_WRITE", "ORDERS_READ", "ORDERS_WRITE", "ITEMS_READ", "ITEMS_WRITE", "INVOICES_READ", "INVOICES_WRITE"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript squareIntegration({ clientId: process.env.CUSTOM_SQUARE_ID, clientSecret: process.env.CUSTOM_SQUARE_SECRET, scopes: ["MERCHANT_PROFILE_READ", "PAYMENTS_READ", "PAYMENTS_WRITE", "CUSTOMERS_READ", "CUSTOMERS_WRITE", "ORDERS_READ", "ORDERS_WRITE", "ITEMS_READ", "ITEMS_WRITE", "INVOICES_READ", "INVOICES_WRITE"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("square"); const result = await client.square.getMerchant({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, squareIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [squareIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `MERCHANT_PROFILE_READ` * `PAYMENTS_READ` * `PAYMENTS_WRITE` * `CUSTOMERS_READ` * `CUSTOMERS_WRITE` * `ORDERS_READ` * `ORDERS_WRITE` * `ITEMS_READ` * `ITEMS_WRITE` * `INVOICES_READ` * `INVOICES_WRITE` Tools [#tools] square_get_merchant [#square_get_merchant] Get merchant *No parameters.* square_list_locations [#square_list_locations] List locations *No parameters.* square_list_customers [#square_list_customers] List customers square_get_customer [#square_get_customer] Get customer square_create_customer [#square_create_customer] Create customer square_update_customer [#square_update_customer] Update customer square_delete_customer [#square_delete_customer] Delete customer square_search_catalog [#square_search_catalog] Search catalog square_retrieve_catalog_object [#square_retrieve_catalog_object] Retrieve catalog object square_upsert_catalog_object [#square_upsert_catalog_object] Upsert catalog object square_search_orders [#square_search_orders] Search orders square_create_order [#square_create_order] Create order square_pay_order [#square_pay_order] Pay order square_list_payments [#square_list_payments] List payments square_get_payment [#square_get_payment] Get payment square_create_payment [#square_create_payment] Create payment square_list_refunds [#square_list_refunds] List refunds square_refund_payment [#square_refund_payment] Refund payment square_list_invoices [#square_list_invoices] List invoices square_get_invoice [#square_get_invoice] Get invoice square_create_invoice [#square_create_invoice] Create invoice Notes [#notes] * Category: Finance * Authentication mode: OAuth # Squarespace Integration The Squarespace integration provides access to manage Squarespace commerce orders, products, inventory, and profiles through the Integrate MCP server. Installation [#installation] The Squarespace integration is included with the SDK: ```typescript import { squarespaceIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Squarespace OAuth App [#1-create-a-squarespace-oauth-app] 1. Create an OAuth application for Squarespace 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Squarespace integration to your server configuration. The integration automatically reads `SQUARESPACE_CLIENT_ID` and `SQUARESPACE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, squarespaceIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ squarespaceIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript squarespaceIntegration({ clientId: process.env.CUSTOM_SQUARESPACE_ID, clientSecret: process.env.CUSTOM_SQUARESPACE_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("squarespace"); const result = await client.squarespace.listOrders({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, squarespaceIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [squarespaceIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] squarespace_list_orders [#squarespace_list_orders] List orders squarespace_get_order [#squarespace_get_order] Get order squarespace_list_products [#squarespace_list_products] List products squarespace_get_product [#squarespace_get_product] Get product squarespace_list_inventory [#squarespace_list_inventory] List inventory squarespace_adjust_inventory [#squarespace_adjust_inventory] Adjust inventory Notes [#notes] * Category: Websites & CMS * Authentication mode: OAuth # Strava Integration The Strava integration provides access to manage Strava athletes, activities, routes, clubs, segments, streams, gear, and uploads through the Integrate MCP server. Installation [#installation] The Strava integration is included with the SDK: ```typescript import { stravaIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Strava OAuth App [#1-create-a-strava-oauth-app] 1. Create an OAuth application for Strava 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Strava integration to your server configuration. The integration automatically reads `STRAVA_CLIENT_ID` and `STRAVA_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, stravaIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ stravaIntegration({ scopes: ["read", "profile:read_all", "profile:write", "activity:read", "activity:read_all", "activity:write"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript stravaIntegration({ clientId: process.env.CUSTOM_STRAVA_ID, clientSecret: process.env.CUSTOM_STRAVA_SECRET, scopes: ["read", "profile:read_all", "profile:write", "activity:read", "activity:read_all", "activity:write"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("strava"); const result = await client.strava.getLoggedInAthlete({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, stravaIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [stravaIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `read` * `profile:read_all` * `profile:write` * `activity:read` * `activity:read_all` * `activity:write` Tools [#tools] strava_get_logged_in_athlete [#strava_get_logged_in_athlete] Get logged in athlete *No parameters.* strava_update_logged_in_athlete [#strava_update_logged_in_athlete] Update logged in athlete strava_get_athlete_stats [#strava_get_athlete_stats] Get athlete stats strava_list_athlete_activities [#strava_list_athlete_activities] List athlete activities strava_get_activity [#strava_get_activity] Get activity strava_create_activity [#strava_create_activity] Create activity strava_update_activity [#strava_update_activity] Update activity strava_delete_activity [#strava_delete_activity] Delete activity strava_get_activity_streams [#strava_get_activity_streams] Get activity streams strava_list_athlete_routes [#strava_list_athlete_routes] List athlete routes strava_get_route [#strava_get_route] Get route strava_export_route_gpx [#strava_export_route_gpx] Export route gpx strava_list_athlete_clubs [#strava_list_athlete_clubs] List athlete clubs strava_get_club [#strava_get_club] Get club strava_list_club_activities [#strava_list_club_activities] List club activities strava_list_club_members [#strava_list_club_members] List club members strava_get_segment [#strava_get_segment] Get segment strava_explore_segments [#strava_explore_segments] Explore segments strava_get_segment_leaderboard [#strava_get_segment_leaderboard] Get segment leaderboard strava_list_starred_segments [#strava_list_starred_segments] List starred segments strava_star_segment [#strava_star_segment] Star segment strava_get_gear [#strava_get_gear] Get gear strava_get_upload [#strava_get_upload] Get upload strava_create_upload [#strava_create_upload] Create upload Notes [#notes] * Category: Fitness * Authentication mode: OAuth # Stripe Integration The Stripe integration provides access to manage Stripe customers, payments, and subscriptions through the Integrate MCP server. Installation [#installation] The Stripe integration is included with the SDK: ```typescript import { stripeIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Stripe OAuth App [#1-create-a-stripe-oauth-app] 1. Go to [Stripe Connect Settings](https://dashboard.stripe.com/settings/applications) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Stripe integration to your server configuration. The integration automatically reads `STRIPE_CLIENT_ID` and `STRIPE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, stripeIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ stripeIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript stripeIntegration({ clientId: process.env.CUSTOM_STRIPE_ID, clientSecret: process.env.CUSTOM_STRIPE_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("stripe"); const result = await client.stripe.listCustomers({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, stripeIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [stripeIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] stripe_list_customers [#stripe_list_customers] List customers stripe_get_customer [#stripe_get_customer] Get a specific customer stripe_create_customer [#stripe_create_customer] Create a new customer stripe_update_customer [#stripe_update_customer] Update an existing customer stripe_delete_customer [#stripe_delete_customer] Delete a customer stripe_search_customers [#stripe_search_customers] Search customers using Stripe search syntax stripe_list_payments [#stripe_list_payments] List payment intents stripe_get_payment [#stripe_get_payment] Get a specific payment intent stripe_create_payment [#stripe_create_payment] Create a payment intent stripe_cancel_payment [#stripe_cancel_payment] Cancel a payment intent stripe_capture_payment [#stripe_capture_payment] Capture an authorized payment intent stripe_list_subscriptions [#stripe_list_subscriptions] List subscriptions stripe_get_subscription [#stripe_get_subscription] Get a subscription by ID stripe_create_subscription [#stripe_create_subscription] Create a subscription stripe_update_subscription [#stripe_update_subscription] Update a subscription stripe_cancel_subscription [#stripe_cancel_subscription] Cancel a subscription stripe_list_invoices [#stripe_list_invoices] List invoices stripe_get_invoice [#stripe_get_invoice] Get an invoice by ID stripe_create_invoice [#stripe_create_invoice] Create an invoice for a customer stripe_finalize_invoice [#stripe_finalize_invoice] Finalize a draft invoice stripe_pay_invoice [#stripe_pay_invoice] Pay an open invoice immediately stripe_void_invoice [#stripe_void_invoice] Void an invoice (cannot be undone) stripe_list_products [#stripe_list_products] List products stripe_get_product [#stripe_get_product] Get a product by ID stripe_create_product [#stripe_create_product] Create a product stripe_list_prices [#stripe_list_prices] List prices stripe_get_price [#stripe_get_price] Get a price by ID stripe_create_price [#stripe_create_price] Create a price for a product stripe_list_refunds [#stripe_list_refunds] List refunds stripe_get_refund [#stripe_get_refund] Get a refund by ID stripe_create_refund [#stripe_create_refund] Create a refund for a payment stripe_get_balance [#stripe_get_balance] Get the current Stripe account balance *No parameters.* stripe_list_events [#stripe_list_events] List events from the Stripe event log stripe_get_event [#stripe_get_event] Get a specific event by ID stripe_list_payment_methods [#stripe_list_payment_methods] List payment methods for a customer Notes [#notes] * Category: Finance * Authentication mode: OAuth # Supabase Integration The Supabase integration provides access to manage Supabase organizations, projects, Postgres settings, API keys, secrets, and branches via the Management API through the Integrate MCP server. Installation [#installation] The Supabase integration is included with the SDK: ```typescript import { supabaseIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Supabase to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, supabaseIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ supabaseIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.supabase.getProfile({}); console.log(result); ``` Environment Variables [#environment-variables] * `SUPABASE_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] supabase_get_profile [#supabase_get_profile] Get profile *No parameters.* supabase_list_organizations [#supabase_list_organizations] List organizations *No parameters.* supabase_get_organization [#supabase_get_organization] Get organization supabase_list_organization_projects [#supabase_list_organization_projects] List organization projects supabase_list_projects [#supabase_list_projects] List projects *No parameters.* supabase_get_project [#supabase_get_project] Get project supabase_create_project [#supabase_create_project] Create project supabase_update_project [#supabase_update_project] Update project supabase_delete_project [#supabase_delete_project] Delete project supabase_list_project_api_keys [#supabase_list_project_api_keys] List project api keys supabase_create_project_api_key [#supabase_create_project_api_key] Create project api key supabase_delete_project_api_key [#supabase_delete_project_api_key] Delete project api key supabase_list_project_secrets [#supabase_list_project_secrets] List project secrets supabase_list_project_branches [#supabase_list_project_branches] List project branches supabase_get_project_health [#supabase_get_project_health] Get project health supabase_get_database_postgres_config [#supabase_get_database_postgres_config] Get database postgres config supabase_list_available_regions [#supabase_list_available_regions] List available regions *No parameters.* Notes [#notes] * Category: Infrastructure * Authentication mode: API key # Tableau Integration The Tableau integration provides access to manage Tableau list sites, list workbooks, get workbook, list views, list datasources through the Integrate MCP server. Installation [#installation] The Tableau integration is included with the SDK: ```typescript import { tableauIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Tableau OAuth App [#1-create-a-tableau-oauth-app] 1. Create an OAuth application for Tableau 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Tableau integration to your server configuration. The integration automatically reads `TABLEAU_CLIENT_ID` and `TABLEAU_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, tableauIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ tableauIntegration({ scopes: ["tableau:content:read", "tableau:content:write", "tableau:users:read"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript tableauIntegration({ clientId: process.env.CUSTOM_TABLEAU_ID, clientSecret: process.env.CUSTOM_TABLEAU_SECRET, scopes: ["tableau:content:read", "tableau:content:write", "tableau:users:read"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("tableau"); const result = await client.tableau.listSites({ tableau_base_url: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, tableauIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [tableauIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `tableau:content:read` * `tableau:content:write` * `tableau:users:read` Tools [#tools] tableau_list_sites [#tableau_list_sites] List sites tableau_list_workbooks [#tableau_list_workbooks] List workbooks tableau_get_workbook [#tableau_get_workbook] Get workbook tableau_list_views [#tableau_list_views] List views tableau_list_datasources [#tableau_list_datasources] List datasources tableau_run_query_view_data [#tableau_run_query_view_data] Run query view data Notes [#notes] * Category: Data & BI * Authentication mode: OAuth # Microsoft Teams Integration The Microsoft Teams integration provides access to collaborate in Teams channels and chats using Microsoft Graph β€” teams, channels, messages, and profile. through the Integrate MCP server. Installation [#installation] The Microsoft Teams integration is included with the SDK: ```typescript import { teamsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Microsoft Teams OAuth App [#1-create-a-microsoft-teams-oauth-app] 1. Go to [Azure Portal β€” App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Microsoft Teams integration to your server configuration. The integration automatically reads `TEAMS_CLIENT_ID` and `TEAMS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, teamsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ teamsIntegration({ scopes: ["offline_access", "User.Read", "Team.ReadBasic.All", "Channel.ReadBasic.All", "ChannelMessage.Read.All", "ChannelMessage.Send", "Chat.Read", "Chat.ReadWrite"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript teamsIntegration({ clientId: process.env.CUSTOM_TEAMS_ID, clientSecret: process.env.CUSTOM_TEAMS_SECRET, scopes: ["offline_access", "User.Read", "Team.ReadBasic.All", "Channel.ReadBasic.All", "ChannelMessage.Read.All", "ChannelMessage.Send", "Chat.Read", "Chat.ReadWrite"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("teams"); const result = await client.teams.getChannel({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, teamsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [teamsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `offline_access` * `User.Read` * `Team.ReadBasic.All` * `Channel.ReadBasic.All` * `ChannelMessage.Read.All` * `ChannelMessage.Send` * `Chat.Read` * `Chat.ReadWrite` Tools [#tools] teams_get_channel [#teams_get_channel] Get channel teams_get_chat [#teams_get_chat] Get chat teams_get_profile [#teams_get_profile] Get profile teams_get_team [#teams_get_team] Get team teams_list_channel_messages [#teams_list_channel_messages] List channel messages teams_list_channels [#teams_list_channels] List channels teams_list_chat_messages [#teams_list_chat_messages] List chat messages teams_list_chats [#teams_list_chats] List chats teams_list_teams [#teams_list_teams] List teams teams_reply_channel_message [#teams_reply_channel_message] Reply channel message teams_send_channel_message [#teams_send_channel_message] Send channel message teams_send_chat_message [#teams_send_chat_message] Send chat message Notes [#notes] * Category: Communication * Authentication mode: OAuth # Telegram Integration The Telegram integration provides access to use Telegram as an actual user account via MTProto sessions, not the Bot API through the Integrate MCP server. Installation [#installation] The Telegram integration is included with the SDK: ```typescript import { telegramIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Telegram to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, telegramIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ telegramIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.telegram.authSendCode({ phone_number: "value", }); console.log(result); ``` Environment Variables [#environment-variables] * `TELEGRAM_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] telegram_auth_send_code [#telegram_auth_send_code] Auth send code telegram_auth_sign_in [#telegram_auth_sign_in] Auth sign in telegram_auth_check_password [#telegram_auth_check_password] Auth check password telegram_get_me [#telegram_get_me] Get me telegram_resolve_username [#telegram_resolve_username] Resolve username telegram_list_dialogs [#telegram_list_dialogs] List dialogs telegram_get_history [#telegram_get_history] Get history telegram_search_messages [#telegram_search_messages] Search messages telegram_send_message [#telegram_send_message] Send message Notes [#notes] * Category: Communication * Authentication mode: API key # Tesla Integration The Tesla integration provides access to manage Tesla list vehicles, get vehicle, wake vehicle, send vehicle command, list energy sites through the Integrate MCP server. Installation [#installation] The Tesla integration is included with the SDK: ```typescript import { teslaIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Tesla OAuth App [#1-create-a-tesla-oauth-app] 1. Create an OAuth application for Tesla 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Tesla integration to your server configuration. The integration automatically reads `TESLA_CLIENT_ID` and `TESLA_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, teslaIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ teslaIntegration({ scopes: ["openid", "offline_access", "vehicle_device_data", "vehicle_cmds", "energy_device_data", "energy_cmds"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript teslaIntegration({ clientId: process.env.CUSTOM_TESLA_ID, clientSecret: process.env.CUSTOM_TESLA_SECRET, scopes: ["openid", "offline_access", "vehicle_device_data", "vehicle_cmds", "energy_device_data", "energy_cmds"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("tesla"); const result = await client.tesla.listVehicles({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, teslaIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [teslaIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `openid` * `offline_access` * `vehicle_device_data` * `vehicle_cmds` * `energy_device_data` * `energy_cmds` Tools [#tools] tesla_list_vehicles [#tesla_list_vehicles] List vehicles *No parameters.* tesla_get_vehicle [#tesla_get_vehicle] Get vehicle tesla_wake_vehicle [#tesla_wake_vehicle] Wake vehicle tesla_send_vehicle_command [#tesla_send_vehicle_command] Send vehicle command tesla_list_energy_sites [#tesla_list_energy_sites] List energy sites *No parameters.* Notes [#notes] * Category: Lifestyle * Authentication mode: OAuth # Threads Integration The Threads integration provides access to publish Threads posts and manage media, replies, conversations, and keyword search through the Integrate MCP server. Installation [#installation] The Threads integration is included with the SDK: ```typescript import { threadsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Threads OAuth App [#1-create-a-threads-oauth-app] 1. Go to [Threads Developer Portal](https://threads.net) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Threads integration to your server configuration. The integration automatically reads `THREADS_CLIENT_ID` and `THREADS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, threadsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ threadsIntegration({ scopes: ["threads_basic", "threads_content_publish", "threads_read_replies", "threads_manage_replies", "threads_manage_insights", "threads_keyword_search", "threads_profile_discovery", "threads_manage_mentions"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript threadsIntegration({ clientId: process.env.CUSTOM_THREADS_ID, clientSecret: process.env.CUSTOM_THREADS_SECRET, scopes: ["threads_basic", "threads_content_publish", "threads_read_replies", "threads_manage_replies", "threads_manage_insights", "threads_keyword_search", "threads_profile_discovery", "threads_manage_mentions"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("threads"); const result = await client.threads.getMe({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, threadsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [threadsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `threads_basic` * `threads_content_publish` * `threads_read_replies` * `threads_manage_replies` * `threads_manage_insights` * `threads_keyword_search` * `threads_profile_discovery` * `threads_manage_mentions` Tools [#tools] threads_get_me [#threads_get_me] Get me threads_list_user_media [#threads_list_user_media] List user media threads_get_media [#threads_get_media] Get media threads_keyword_search [#threads_keyword_search] Keyword search threads_create_media_container [#threads_create_media_container] Create media container threads_publish_media_container [#threads_publish_media_container] Publish media container threads_get_container_status [#threads_get_container_status] Get container status threads_list_replies [#threads_list_replies] List replies threads_get_conversation [#threads_get_conversation] Get conversation threads_manage_reply [#threads_manage_reply] Manage reply threads_repost [#threads_repost] Repost threads_delete_media [#threads_delete_media] Delete media Notes [#notes] * Category: Social Media * Authentication mode: OAuth # TikTok Integration The TikTok integration provides access to read TikTok user profile data and user-authorized video metadata through the Integrate MCP server. Installation [#installation] The TikTok integration is included with the SDK: ```typescript import { tiktokIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a TikTok OAuth App [#1-create-a-tiktok-oauth-app] 1. Go to [Tiktok Developer Portal](https://www.tiktok.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the TikTok integration to your server configuration. The integration automatically reads `TIKTOK_CLIENT_ID` and `TIKTOK_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, tiktokIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ tiktokIntegration({ scopes: ["user.info.basic", "video.list"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript tiktokIntegration({ clientId: process.env.CUSTOM_TIKTOK_ID, clientSecret: process.env.CUSTOM_TIKTOK_SECRET, scopes: ["user.info.basic", "video.list"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("tiktok"); const result = await client.tiktok.getUserInfo({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, tiktokIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [tiktokIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `user.info.basic` * `video.list` Tools [#tools] tiktok_get_user_info [#tiktok_get_user_info] Get user info tiktok_list_videos [#tiktok_list_videos] List videos tiktok_query_videos [#tiktok_query_videos] Query videos Notes [#notes] * Category: Entertainment * Authentication mode: OAuth # TikTok Business Integration The TikTok Business integration provides access to manage TikTok Business list advertisers, list campaigns, create campaign, list adgroups, list ads through the Integrate MCP server. Installation [#installation] The TikTok Business integration is included with the SDK: ```typescript import { tiktokBusinessIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a TikTok Business OAuth App [#1-create-a-tiktok-business-oauth-app] 1. Create an OAuth application for TikTok Business 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the TikTok Business integration to your server configuration. The integration automatically reads `TIKTOK_BUSINESS_CLIENT_ID` and `TIKTOK_BUSINESS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, tiktokBusinessIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ tiktokBusinessIntegration({ scopes: ["user.info.basic", "advertiser.read", "campaign.read", "campaign.write", "adgroup.read", "adgroup.write", "ad.read", "ad.write", "report.read"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript tiktokBusinessIntegration({ clientId: process.env.CUSTOM_TIKTOK_BUSINESS_ID, clientSecret: process.env.CUSTOM_TIKTOK_BUSINESS_SECRET, scopes: ["user.info.basic", "advertiser.read", "campaign.read", "campaign.write", "adgroup.read", "adgroup.write", "ad.read", "ad.write", "report.read"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("tiktok_business"); const result = await client.tiktok_business.listAdvertisers({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, tiktokBusinessIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [tiktokBusinessIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `user.info.basic` * `advertiser.read` * `campaign.read` * `campaign.write` * `adgroup.read` * `adgroup.write` * `ad.read` * `ad.write` * `report.read` Tools [#tools] tiktok_business_list_advertisers [#tiktok_business_list_advertisers] Business list advertisers *No parameters.* tiktok_business_list_campaigns [#tiktok_business_list_campaigns] Business list campaigns tiktok_business_create_campaign [#tiktok_business_create_campaign] Business create campaign tiktok_business_list_adgroups [#tiktok_business_list_adgroups] Business list adgroups tiktok_business_list_ads [#tiktok_business_list_ads] Business list ads tiktok_business_run_report [#tiktok_business_run_report] Business run report Notes [#notes] * Category: Marketing * Authentication mode: OAuth # Tink Integration The Tink integration provides access to manage Tink get user, list accounts, get account, list transactions, list credentials through the Integrate MCP server. Installation [#installation] The Tink integration is included with the SDK: ```typescript import { tinkIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Tink OAuth App [#1-create-a-tink-oauth-app] 1. Create an OAuth application for Tink 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Tink integration to your server configuration. The integration automatically reads `TINK_CLIENT_ID` and `TINK_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, tinkIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ tinkIntegration({ scopes: ["accounts:read", "transactions:read", "user:read", "credentials:read"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript tinkIntegration({ clientId: process.env.CUSTOM_TINK_ID, clientSecret: process.env.CUSTOM_TINK_SECRET, scopes: ["accounts:read", "transactions:read", "user:read", "credentials:read"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("tink"); const result = await client.tink.getUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, tinkIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [tinkIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `accounts:read` * `transactions:read` * `user:read` * `credentials:read` Tools [#tools] tink_get_user [#tink_get_user] Get user *No parameters.* tink_list_accounts [#tink_list_accounts] List accounts *No parameters.* tink_get_account [#tink_get_account] Get account tink_list_transactions [#tink_list_transactions] List transactions tink_list_credentials [#tink_list_credentials] List credentials *No parameters.* tink_refresh_credentials [#tink_refresh_credentials] Refresh credentials Notes [#notes] * Category: Banking * Authentication mode: OAuth # tldraw Integration The tldraw integration provides access to create and manage tldraw collaborative whiteboards through the Integrate MCP server. Installation [#installation] The tldraw integration is included with the SDK: ```typescript import { tldrawIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add tldraw to your server configuration: ```typescript import { createMCPServer, tldrawIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ tldrawIntegration(), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; // Use client.tldraw methods after connecting ``` Configuration Options [#configuration-options] Tools [#tools] tldraw_unfurl_url [#tldraw_unfurl_url] Unfurl url *No parameters.* tldraw_create_room_snapshot [#tldraw_create_room_snapshot] Create room snapshot *No parameters.* tldraw_get_room_snapshot [#tldraw_get_room_snapshot] Get room snapshot *No parameters.* tldraw_get_published_snapshot [#tldraw_get_published_snapshot] Get published snapshot *No parameters.* tldraw_get_readonly_slug [#tldraw_get_readonly_slug] Get readonly slug *No parameters.* Notes [#notes] * Category: Productivity * Authentication mode: None # Todoist Integration The Todoist integration provides access to manage Todoist tasks, projects, and labels through the Integrate MCP server. Installation [#installation] The Todoist integration is included with the SDK: ```typescript import { todoistIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Todoist OAuth App [#1-create-a-todoist-oauth-app] 1. Go to [Todoist App Console](https://developer.todoist.com/appconsole.html) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Todoist integration to your server configuration. The integration automatically reads `TODOIST_CLIENT_ID` and `TODOIST_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, todoistIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ todoistIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript todoistIntegration({ clientId: process.env.CUSTOM_TODOIST_ID, clientSecret: process.env.CUSTOM_TODOIST_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("todoist"); const result = await client.todoist.listProjects({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, todoistIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [todoistIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] todoist_list_projects [#todoist_list_projects] List all projects *No parameters.* todoist_get_project [#todoist_get_project] Get details of a specific project todoist_create_project [#todoist_create_project] Create a new project todoist_update_project [#todoist_update_project] Update an existing project todoist_delete_project [#todoist_delete_project] Delete a project todoist_archive_project [#todoist_archive_project] Archive a project todoist_list_tasks [#todoist_list_tasks] List active tasks with optional filters todoist_get_task [#todoist_get_task] Get details of a specific task todoist_create_task [#todoist_create_task] Create a new task todoist_update_task [#todoist_update_task] Update an existing task todoist_complete_task [#todoist_complete_task] Mark a task as complete todoist_delete_task [#todoist_delete_task] Delete a task permanently todoist_reopen_task [#todoist_reopen_task] Reopen a completed task todoist_move_task [#todoist_move_task] Move a task to a different project, section, or parent todoist_quick_add_task [#todoist_quick_add_task] Add a task using natural language todoist_get_completed_tasks [#todoist_get_completed_tasks] Get completed tasks todoist_filter_tasks [#todoist_filter_tasks] Get tasks matching a Todoist filter expression todoist_list_sections [#todoist_list_sections] List sections, optionally filtered by project todoist_create_section [#todoist_create_section] Create a new section in a project todoist_get_section [#todoist_get_section] Get details of a specific section todoist_update_section [#todoist_update_section] Rename a section todoist_delete_section [#todoist_delete_section] Delete a section (and all tasks in it) todoist_list_comments [#todoist_list_comments] List comments on a task or project todoist_create_comment [#todoist_create_comment] Add a comment to a task or project todoist_get_comment [#todoist_get_comment] Get details of a specific comment todoist_update_comment [#todoist_update_comment] Update a comment's text todoist_delete_comment [#todoist_delete_comment] Delete a comment todoist_list_labels [#todoist_list_labels] List all personal labels *No parameters.* todoist_create_label [#todoist_create_label] Create a new label todoist_update_label [#todoist_update_label] Update a label todoist_delete_label [#todoist_delete_label] Delete a label todoist_list_reminders [#todoist_list_reminders] List all reminders *No parameters.* todoist_create_reminder [#todoist_create_reminder] Create a reminder for a task Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Trello Integration The Trello integration provides access to manage Trello boards, lists, cards, comments, and search through the Integrate MCP server. Installation [#installation] The Trello integration is included with the SDK: ```typescript import { trelloIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Trello to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, trelloIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ trelloIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.trello.getMember({}); console.log(result); ``` Environment Variables [#environment-variables] * `TRELLO_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] trello_get_member [#trello_get_member] Get member trello_list_boards [#trello_list_boards] List boards trello_get_board [#trello_get_board] Get board trello_list_lists [#trello_list_lists] List lists trello_get_list [#trello_get_list] Get list trello_list_cards [#trello_list_cards] List cards trello_get_card [#trello_get_card] Get card trello_create_card [#trello_create_card] Create card trello_update_card [#trello_update_card] Update card trello_delete_card [#trello_delete_card] Delete card trello_add_card_comment [#trello_add_card_comment] Add card comment trello_search [#trello_search] Search Notes [#notes] * Category: Productivity * Authentication mode: API key # TrueLayer Integration The TrueLayer integration provides access to manage TrueLayer get me, list accounts, get account, get balance, list transactions through the Integrate MCP server. Installation [#installation] The TrueLayer integration is included with the SDK: ```typescript import { truelayerIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a TrueLayer OAuth App [#1-create-a-truelayer-oauth-app] 1. Create an OAuth application for TrueLayer 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the TrueLayer integration to your server configuration. The integration automatically reads `TRUELAYER_CLIENT_ID` and `TRUELAYER_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, truelayerIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ truelayerIntegration({ scopes: ["info", "accounts", "balance", "cards", "transactions", "direct_debits", "standing_orders", "offline_access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript truelayerIntegration({ clientId: process.env.CUSTOM_TRUELAYER_ID, clientSecret: process.env.CUSTOM_TRUELAYER_SECRET, scopes: ["info", "accounts", "balance", "cards", "transactions", "direct_debits", "standing_orders", "offline_access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("truelayer"); const result = await client.truelayer.getMe({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, truelayerIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [truelayerIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `info` * `accounts` * `balance` * `cards` * `transactions` * `direct_debits` * `standing_orders` * `offline_access` Tools [#tools] truelayer_get_me [#truelayer_get_me] Get me *No parameters.* truelayer_list_accounts [#truelayer_list_accounts] List accounts *No parameters.* truelayer_get_account [#truelayer_get_account] Get account truelayer_get_balance [#truelayer_get_balance] Get balance truelayer_list_transactions [#truelayer_list_transactions] List transactions truelayer_list_cards [#truelayer_list_cards] List cards *No parameters.* Notes [#notes] * Category: Banking * Authentication mode: OAuth # Tuya Integration The Tuya integration provides access to manage Tuya list devices, get device, get device status, send device commands, list scenes through the Integrate MCP server. Installation [#installation] The Tuya integration is included with the SDK: ```typescript import { tuyaIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Tuya OAuth App [#1-create-a-tuya-oauth-app] 1. Create an OAuth application for Tuya 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Tuya integration to your server configuration. The integration automatically reads `TUYA_CLIENT_ID` and `TUYA_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, tuyaIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ tuyaIntegration({ scopes: ["device:read", "device:write", "home:read", "scene:read", "scene:write"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript tuyaIntegration({ clientId: process.env.CUSTOM_TUYA_ID, clientSecret: process.env.CUSTOM_TUYA_SECRET, scopes: ["device:read", "device:write", "home:read", "scene:read", "scene:write"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("tuya"); const result = await client.tuya.listDevices({ user_id: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, tuyaIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [tuyaIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `device:read` * `device:write` * `home:read` * `scene:read` * `scene:write` Tools [#tools] tuya_list_devices [#tuya_list_devices] List devices tuya_get_device [#tuya_get_device] Get device tuya_get_device_status [#tuya_get_device_status] Get device status tuya_send_device_commands [#tuya_send_device_commands] Send device commands tuya_list_scenes [#tuya_list_scenes] List scenes Notes [#notes] * Category: Lifestyle * Authentication mode: OAuth # Twitch Integration The Twitch integration provides access to manage Twitch users, streams, channels, clips, videos, games, follows, and subscriptions through the Integrate MCP server. Installation [#installation] The Twitch integration is included with the SDK: ```typescript import { twitchIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Twitch OAuth App [#1-create-a-twitch-oauth-app] 1. Create an OAuth application for Twitch 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Twitch integration to your server configuration. The integration automatically reads `TWITCH_CLIENT_ID` and `TWITCH_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, twitchIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ twitchIntegration({ scopes: ["user:read:email", "channel:read:subscriptions", "clips:edit", "channel:manage:broadcast", "user:read:follows"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript twitchIntegration({ clientId: process.env.CUSTOM_TWITCH_ID, clientSecret: process.env.CUSTOM_TWITCH_SECRET, scopes: ["user:read:email", "channel:read:subscriptions", "clips:edit", "channel:manage:broadcast", "user:read:follows"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("twitch"); const result = await client.twitch.getUsers({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, twitchIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [twitchIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `user:read:email` * `channel:read:subscriptions` * `clips:edit` * `channel:manage:broadcast` * `user:read:follows` Tools [#tools] twitch_get_users [#twitch_get_users] Get users twitch_get_streams [#twitch_get_streams] Get streams twitch_get_channels [#twitch_get_channels] Get channels twitch_modify_channel [#twitch_modify_channel] Modify channel twitch_create_clip [#twitch_create_clip] Create clip twitch_get_videos [#twitch_get_videos] Get videos twitch_get_games [#twitch_get_games] Get games twitch_get_channel_followers [#twitch_get_channel_followers] Get channel followers twitch_get_broadcaster_subscriptions [#twitch_get_broadcaster_subscriptions] Get broadcaster subscriptions Notes [#notes] * Category: Entertainment * Authentication mode: OAuth # Typeform Integration The Typeform integration provides access to manage Typeform workspaces, forms, and responses through the Integrate MCP server. Installation [#installation] The Typeform integration is included with the SDK: ```typescript import { typeformIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Typeform OAuth App [#1-create-a-typeform-oauth-app] 1. Go to [Api Developer Portal](https://api.typeform.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Typeform integration to your server configuration. The integration automatically reads `TYPEFORM_CLIENT_ID` and `TYPEFORM_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, typeformIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ typeformIntegration({ scopes: ["offline", "accounts:read", "forms:read", "forms:write", "responses:read", "workspaces:read"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript typeformIntegration({ clientId: process.env.CUSTOM_TYPEFORM_ID, clientSecret: process.env.CUSTOM_TYPEFORM_SECRET, scopes: ["offline", "accounts:read", "forms:read", "forms:write", "responses:read", "workspaces:read"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("typeform"); const result = await client.typeform.getMe({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, typeformIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [typeformIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `offline` * `accounts:read` * `forms:read` * `forms:write` * `responses:read` * `workspaces:read` Tools [#tools] typeform_get_me [#typeform_get_me] Get me *No parameters.* typeform_list_workspaces [#typeform_list_workspaces] List workspaces typeform_get_workspace [#typeform_get_workspace] Get workspace typeform_list_forms [#typeform_list_forms] List forms typeform_get_form [#typeform_get_form] Get form typeform_create_form [#typeform_create_form] Create form typeform_update_form [#typeform_update_form] Update form typeform_delete_form [#typeform_delete_form] Delete form typeform_list_responses [#typeform_list_responses] List responses Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Uber Integration The Uber integration provides access to manage Uber get profile, list products, estimate price, estimate time, list requests through the Integrate MCP server. Installation [#installation] The Uber integration is included with the SDK: ```typescript import { uberIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Uber OAuth App [#1-create-an-uber-oauth-app] 1. Create an OAuth application for Uber 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Uber integration to your server configuration. The integration automatically reads `UBER_CLIENT_ID` and `UBER_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, uberIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ uberIntegration({ scopes: ["profile", "request", "history", "places"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript uberIntegration({ clientId: process.env.CUSTOM_UBER_ID, clientSecret: process.env.CUSTOM_UBER_SECRET, scopes: ["profile", "request", "history", "places"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("uber"); const result = await client.uber.getProfile({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, uberIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [uberIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `profile` * `request` * `history` * `places` Tools [#tools] uber_get_profile [#uber_get_profile] Get profile *No parameters.* uber_list_products [#uber_list_products] List products uber_estimate_price [#uber_estimate_price] Estimate price uber_estimate_time [#uber_estimate_time] Estimate time uber_list_requests [#uber_list_requests] List requests uber_create_request [#uber_create_request] Create request Notes [#notes] * Category: Travel * Authentication mode: OAuth # Uber Eats Integration The Uber Eats integration provides access to manage Uber Eats list stores, get store, list orders, get order, update order status through the Integrate MCP server. Installation [#installation] The Uber Eats integration is included with the SDK: ```typescript import { uberEatsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Uber Eats OAuth App [#1-create-an-uber-eats-oauth-app] 1. Create an OAuth application for Uber Eats 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Uber Eats integration to your server configuration. The integration automatically reads `UBER_EATS_CLIENT_ID` and `UBER_EATS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, uberEatsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ uberEatsIntegration({ scopes: ["eats.store", "eats.order", "eats.report"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript uberEatsIntegration({ clientId: process.env.CUSTOM_UBER_EATS_ID, clientSecret: process.env.CUSTOM_UBER_EATS_SECRET, scopes: ["eats.store", "eats.order", "eats.report"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("uber_eats"); const result = await client.uber_eats.listStores({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, uberEatsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [uberEatsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `eats.store` * `eats.order` * `eats.report` Tools [#tools] uber_eats_list_stores [#uber_eats_list_stores] Eats list stores uber_eats_get_store [#uber_eats_get_store] Eats get store uber_eats_list_orders [#uber_eats_list_orders] Eats list orders uber_eats_get_order [#uber_eats_get_order] Eats get order uber_eats_update_order_status [#uber_eats_update_order_status] Eats update order status uber_eats_get_menu [#uber_eats_get_menu] Eats get menu Notes [#notes] * Category: Food * Authentication mode: OAuth # Universe Integration The Universe integration provides access to manage Universe get user, list events, get event, create event, list orders through the Integrate MCP server. Installation [#installation] The Universe integration is included with the SDK: ```typescript import { universeIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an Universe OAuth App [#1-create-an-universe-oauth-app] 1. Create an OAuth application for Universe 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Universe integration to your server configuration. The integration automatically reads `UNIVERSE_CLIENT_ID` and `UNIVERSE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, universeIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ universeIntegration({ scopes: ["read", "write"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript universeIntegration({ clientId: process.env.CUSTOM_UNIVERSE_ID, clientSecret: process.env.CUSTOM_UNIVERSE_SECRET, scopes: ["read", "write"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("universe"); const result = await client.universe.getUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, universeIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [universeIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `read` * `write` Tools [#tools] universe_get_user [#universe_get_user] Get user *No parameters.* universe_list_events [#universe_list_events] List events universe_get_event [#universe_get_event] Get event universe_create_event [#universe_create_event] Create event universe_list_orders [#universe_list_orders] List orders universe_list_attendees [#universe_list_attendees] List attendees Notes [#notes] * Category: Events & Ticketing * Authentication mode: OAuth # UPS Integration The UPS integration provides access to manage UPS track shipment, rate shipment, create shipment, void shipment, validate address through the Integrate MCP server. Installation [#installation] The UPS integration is included with the SDK: ```typescript import { upsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create an UPS OAuth App [#1-create-an-ups-oauth-app] 1. Create an OAuth application for UPS 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the UPS integration to your server configuration. The integration automatically reads `UPS_CLIENT_ID` and `UPS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, upsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ upsIntegration({ scopes: ["shipments", "tracking", "rating", "address_validation"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript upsIntegration({ clientId: process.env.CUSTOM_UPS_ID, clientSecret: process.env.CUSTOM_UPS_SECRET, scopes: ["shipments", "tracking", "rating", "address_validation"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("ups"); const result = await client.ups.trackShipment({ tracking_number: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, upsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [upsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `shipments` * `tracking` * `rating` * `address_validation` Tools [#tools] ups_track_shipment [#ups_track_shipment] Track shipment ups_rate_shipment [#ups_rate_shipment] Rate shipment ups_create_shipment [#ups_create_shipment] Create shipment ups_void_shipment [#ups_void_shipment] Void shipment ups_validate_address [#ups_validate_address] Validate address Notes [#notes] * Category: Shipping & Logistics * Authentication mode: OAuth # Upstash Integration The Upstash integration provides access to serverless Redis (REST), QStash messaging, and HTTP APIs through the Integrate MCP server. Installation [#installation] The Upstash integration is included with the SDK: ```typescript import { upstashIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Upstash to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, upstashIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ upstashIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.upstash.redisRun({}); console.log(result); ``` Environment Variables [#environment-variables] * `UPSTASH_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] upstash_redis_run [#upstash_redis_run] Redis run upstash_redis_get [#upstash_redis_get] Redis get upstash_redis_set [#upstash_redis_set] Redis set upstash_redis_del [#upstash_redis_del] Redis del upstash_qstash_publish [#upstash_qstash_publish] Qstash publish Notes [#notes] * Category: Infrastructure * Authentication mode: API key # Vercel Integration The Vercel integration provides access to manage Vercel projects, deployments, and domains through the Integrate MCP server. Installation [#installation] The Vercel integration is included with the SDK: ```typescript import { vercelIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Vercel OAuth App [#1-create-a-vercel-oauth-app] 1. Go to [Vercel Integrations](https://vercel.com/dashboard/integrations) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Vercel integration to your server configuration. The integration automatically reads `VERCEL_CLIENT_ID` and `VERCEL_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, vercelIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ vercelIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript vercelIntegration({ clientId: process.env.CUSTOM_VERCEL_ID, clientSecret: process.env.CUSTOM_VERCEL_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("vercel"); const result = await client.vercel.listProjects({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, vercelIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [vercelIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] vercel_list_projects [#vercel_list_projects] List projects in Vercel vercel_get_project [#vercel_get_project] Get a specific project vercel_create_project [#vercel_create_project] Create a new project vercel_update_project [#vercel_update_project] Update an existing project vercel_delete_project [#vercel_delete_project] Delete a project vercel_list_deployments [#vercel_list_deployments] List deployments vercel_get_deployment [#vercel_get_deployment] Get a specific deployment vercel_create_deployment [#vercel_create_deployment] Create a new deployment vercel_cancel_deployment [#vercel_cancel_deployment] Cancel a deployment vercel_delete_deployment [#vercel_delete_deployment] Delete a deployment vercel_promote_deployment [#vercel_promote_deployment] Promote a deployment to production vercel_get_deployment_logs [#vercel_get_deployment_logs] Get deployment logs vercel_list_domains [#vercel_list_domains] List domains for a project vercel_add_domain [#vercel_add_domain] Add a domain to a project vercel_remove_domain [#vercel_remove_domain] Remove a domain from a project vercel_get_domain_config [#vercel_get_domain_config] Get domain configuration vercel_list_env_vars [#vercel_list_env_vars] List environment variables for a project vercel_create_env_var [#vercel_create_env_var] Create an environment variable vercel_delete_env_var [#vercel_delete_env_var] Delete an environment variable vercel_list_dns_records [#vercel_list_dns_records] List DNS records for a domain vercel_create_dns_record [#vercel_create_dns_record] Create a DNS record Notes [#notes] * Category: Infrastructure * Authentication mode: OAuth # Webflow Integration The Webflow integration provides access to manage Webflow sites, CMS collections, pages, forms, and publishing through the Integrate MCP server. Installation [#installation] The Webflow integration is included with the SDK: ```typescript import { webflowIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Webflow OAuth App [#1-create-a-webflow-oauth-app] 1. Go to [Webflow Developer Portal](https://webflow.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Webflow integration to your server configuration. The integration automatically reads `WEBFLOW_CLIENT_ID` and `WEBFLOW_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, webflowIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ webflowIntegration({ scopes: ["authorized_user:read", "assets:read", "assets:write", "cms:read", "cms:write", "custom_code:read", "custom_code:write", "forms:read", "forms:write", "pages:read", "pages:write", "sites:read", "sites:write"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript webflowIntegration({ clientId: process.env.CUSTOM_WEBFLOW_ID, clientSecret: process.env.CUSTOM_WEBFLOW_SECRET, scopes: ["authorized_user:read", "assets:read", "assets:write", "cms:read", "cms:write", "custom_code:read", "custom_code:write", "forms:read", "forms:write", "pages:read", "pages:write", "sites:read", "sites:write"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("webflow"); const result = await client.webflow.tokenIntrospect({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, webflowIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [webflowIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `authorized_user:read` * `assets:read` * `assets:write` * `cms:read` * `cms:write` * `custom_code:read` * `custom_code:write` * `forms:read` * `forms:write` * `pages:read` * `pages:write` * `sites:read` * `sites:write` Tools [#tools] webflow_token_introspect [#webflow_token_introspect] Token introspect *No parameters.* webflow_get_authorized_user [#webflow_get_authorized_user] Get authorized user *No parameters.* webflow_list_sites [#webflow_list_sites] List sites *No parameters.* webflow_get_site [#webflow_get_site] Get site webflow_get_site_custom_domains [#webflow_get_site_custom_domains] Get site custom domains webflow_publish_site [#webflow_publish_site] Publish site webflow_list_site_pages [#webflow_list_site_pages] List site pages webflow_list_site_collections [#webflow_list_site_collections] List site collections webflow_get_collection [#webflow_get_collection] Get collection webflow_list_collection_items [#webflow_list_collection_items] List collection items webflow_list_live_collection_items [#webflow_list_live_collection_items] List live collection items webflow_get_collection_item [#webflow_get_collection_item] Get collection item webflow_create_collection_items [#webflow_create_collection_items] Create collection items webflow_update_collection_items [#webflow_update_collection_items] Update collection items webflow_delete_collection_items [#webflow_delete_collection_items] Delete collection items webflow_publish_collection_items [#webflow_publish_collection_items] Publish collection items webflow_list_site_forms [#webflow_list_site_forms] List site forms webflow_list_site_webhooks [#webflow_list_site_webhooks] List site webhooks Notes [#notes] * Category: Websites & CMS * Authentication mode: OAuth # WhatsApp Business Integration The WhatsApp Business integration provides access to send WhatsApp messages and templates through the Integrate MCP server. Installation [#installation] The WhatsApp Business integration is included with the SDK: ```typescript import { whatsappIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a WhatsApp Business OAuth App [#1-create-a-whatsapp-business-oauth-app] 1. Go to [Meta for Developers](https://developers.facebook.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the WhatsApp Business integration to your server configuration. The integration automatically reads `WHATSAPP_CLIENT_ID` and `WHATSAPP_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, whatsappIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ whatsappIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript whatsappIntegration({ clientId: process.env.CUSTOM_WHATSAPP_ID, clientSecret: process.env.CUSTOM_WHATSAPP_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("whatsapp"); const result = await client.whatsapp.sendMessage({ phone_number_id: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, whatsappIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [whatsappIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] whatsapp_send_message [#whatsapp_send_message] Send a plain text message whatsapp_reply_message [#whatsapp_reply_message] Reply to a specific message (quoted reply) whatsapp_send_template [#whatsapp_send_template] Send a pre-approved template message whatsapp_send_media [#whatsapp_send_media] Send an image, video, document, or audio file by URL whatsapp_send_reaction [#whatsapp_send_reaction] React to a message with an emoji whatsapp_send_location [#whatsapp_send_location] Send a location pin whatsapp_send_contact [#whatsapp_send_contact] Send one or more vCard-style contact cards whatsapp_send_interactive_buttons [#whatsapp_send_interactive_buttons] Send a message with up to 3 quick-reply buttons whatsapp_send_interactive_list [#whatsapp_send_interactive_list] Send a message with a scrollable list of options whatsapp_mark_read [#whatsapp_mark_read] Mark a received message as read (shows blue ticks to sender) whatsapp_get_media_url [#whatsapp_get_media_url] Get the download URL and metadata for a received media object whatsapp_delete_media [#whatsapp_delete_media] Delete an uploaded media object from Meta's servers whatsapp_list_templates [#whatsapp_list_templates] List all message templates for a WhatsApp Business Account whatsapp_get_template [#whatsapp_get_template] Get a specific template by name whatsapp_create_template [#whatsapp_create_template] Create a new message template (submitted for Meta review) whatsapp_delete_template [#whatsapp_delete_template] Delete a template by name (all language variants) whatsapp_get_phone_numbers [#whatsapp_get_phone_numbers] List all phone numbers registered to a WABA whatsapp_get_phone_number [#whatsapp_get_phone_number] Get full details for a specific phone number whatsapp_get_profile [#whatsapp_get_profile] Get the public business profile for a phone number whatsapp_update_profile [#whatsapp_update_profile] Update the business profile (pass only the fields you want to change) whatsapp_get_message_status [#whatsapp_get_message_status] Get status of a sent message by message ID whatsapp_create_qr_code [#whatsapp_create_qr_code] Create a QR code that opens a chat with a prefilled message whatsapp_update_qr_code [#whatsapp_update_qr_code] Update qr code whatsapp_list_qr_codes [#whatsapp_list_qr_codes] List all QR codes for a phone number whatsapp_get_qr_code [#whatsapp_get_qr_code] Get qr code whatsapp_delete_qr_code [#whatsapp_delete_qr_code] Delete qr code Notes [#notes] * Category: Communication * Authentication mode: OAuth # WHOOP Integration The WHOOP integration provides access to manage WHOOP get profile, get body measurement, list cycles, list recovery, list sleep through the Integrate MCP server. Installation [#installation] The WHOOP integration is included with the SDK: ```typescript import { whoopIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a WHOOP OAuth App [#1-create-a-whoop-oauth-app] 1. Create an OAuth application for WHOOP 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the WHOOP integration to your server configuration. The integration automatically reads `WHOOP_CLIENT_ID` and `WHOOP_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, whoopIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ whoopIntegration({ scopes: ["read:profile", "read:cycles", "read:recovery", "read:sleep", "read:workout", "read:body_measurement"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript whoopIntegration({ clientId: process.env.CUSTOM_WHOOP_ID, clientSecret: process.env.CUSTOM_WHOOP_SECRET, scopes: ["read:profile", "read:cycles", "read:recovery", "read:sleep", "read:workout", "read:body_measurement"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("whoop"); const result = await client.whoop.getProfile({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, whoopIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [whoopIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `read:profile` * `read:cycles` * `read:recovery` * `read:sleep` * `read:workout` * `read:body_measurement` Tools [#tools] whoop_get_profile [#whoop_get_profile] Get profile *No parameters.* whoop_get_body_measurement [#whoop_get_body_measurement] Get body measurement *No parameters.* whoop_list_cycles [#whoop_list_cycles] List cycles whoop_list_recovery [#whoop_list_recovery] List recovery whoop_list_sleep [#whoop_list_sleep] List sleep whoop_list_workouts [#whoop_list_workouts] List workouts Notes [#notes] * Category: Fitness * Authentication mode: OAuth # Withings Integration The Withings integration provides access to manage Withings get measurements, get activity, get sleep, get workouts, get user through the Integrate MCP server. Installation [#installation] The Withings integration is included with the SDK: ```typescript import { withingsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Withings OAuth App [#1-create-a-withings-oauth-app] 1. Create an OAuth application for Withings 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Withings integration to your server configuration. The integration automatically reads `WITHINGS_CLIENT_ID` and `WITHINGS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, withingsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ withingsIntegration({ scopes: ["user.info", "user.metrics", "user.activity"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript withingsIntegration({ clientId: process.env.CUSTOM_WITHINGS_ID, clientSecret: process.env.CUSTOM_WITHINGS_SECRET, scopes: ["user.info", "user.metrics", "user.activity"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("withings"); const result = await client.withings.getMeasurements({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, withingsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [withingsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `user.info` * `user.metrics` * `user.activity` Tools [#tools] withings_get_measurements [#withings_get_measurements] Get measurements withings_get_activity [#withings_get_activity] Get activity withings_get_sleep [#withings_get_sleep] Get sleep withings_get_workouts [#withings_get_workouts] Get workouts withings_get_user [#withings_get_user] Get user Notes [#notes] * Category: Fitness * Authentication mode: OAuth # Wix Integration The Wix integration provides access to manage Wix site stores, products, and e-commerce orders via REST through the Integrate MCP server. Installation [#installation] The Wix integration is included with the SDK: ```typescript import { wixIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add Wix to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, wixIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ wixIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.wix.queryProducts({}); console.log(result); ``` Environment Variables [#environment-variables] * `WIX_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] wix_query_products [#wix_query_products] Query products wix_get_product [#wix_get_product] Get product wix_create_product [#wix_create_product] Create product wix_update_product [#wix_update_product] Update product wix_search_orders [#wix_search_orders] Search orders wix_get_order [#wix_get_order] Get order Notes [#notes] * Category: Websites & CMS * Authentication mode: API key # Word Integration The Word integration provides access to manage Word documents and sharing through the Integrate MCP server. Installation [#installation] The Word integration is included with the SDK: ```typescript import { wordIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Word OAuth App [#1-create-a-word-oauth-app] 1. Go to [Azure Portal β€” App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Word integration to your server configuration. The integration automatically reads `WORD_CLIENT_ID` and `WORD_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, wordIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ wordIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript wordIntegration({ clientId: process.env.CUSTOM_WORD_ID, clientSecret: process.env.CUSTOM_WORD_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("word"); const result = await client.word.list({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, wordIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [wordIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] word_copy [#word_copy] Copy a Word document word_create [#word_create] Create a new empty .docx file in OneDrive word_delete [#word_delete] Delete a Word document permanently word_get [#word_get] Get metadata for a Word document word_list [#word_list] Search for Word documents word_share [#word_share] Create a sharing link for a Word document word_update_content [#word_update_content] Update content Notes [#notes] * Category: Productivity * Authentication mode: OAuth # WordPress Integration The WordPress integration provides access to manage WordPress get site, list posts, get post, create post, update post through the Integrate MCP server. Installation [#installation] The WordPress integration is included with the SDK: ```typescript import { wordpressIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a WordPress OAuth App [#1-create-a-wordpress-oauth-app] 1. Create an OAuth application for WordPress 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the WordPress integration to your server configuration. The integration automatically reads `WORDPRESS_CLIENT_ID` and `WORDPRESS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, wordpressIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ wordpressIntegration({ scopes: ["global"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript wordpressIntegration({ clientId: process.env.CUSTOM_WORDPRESS_ID, clientSecret: process.env.CUSTOM_WORDPRESS_SECRET, scopes: ["global"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("wordpress"); const result = await client.wordpress.getSite({ site: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, wordpressIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [wordpressIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `global` Tools [#tools] wordpress_get_site [#wordpress_get_site] Get site wordpress_list_posts [#wordpress_list_posts] List posts wordpress_get_post [#wordpress_get_post] Get post wordpress_create_post [#wordpress_create_post] Create post wordpress_update_post [#wordpress_update_post] Update post wordpress_list_media [#wordpress_list_media] List media Notes [#notes] * Category: Websites & CMS * Authentication mode: OAuth # Workday Integration The Workday integration provides access to query Workday workers via the tenant REST API through the Integrate MCP server. Installation [#installation] The Workday integration is included with the SDK: ```typescript import { workdayIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Workday OAuth App [#1-create-a-workday-oauth-app] 1. Create an OAuth application for Workday 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Workday integration to your server configuration. The integration automatically reads `WORKDAY_CLIENT_ID` and `WORKDAY_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, workdayIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ workdayIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript workdayIntegration({ clientId: process.env.CUSTOM_WORKDAY_ID, clientSecret: process.env.CUSTOM_WORKDAY_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("workday"); const result = await client.workday.listWorkers({ hostname: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, workdayIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [workdayIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] workday_list_workers [#workday_list_workers] List workers workday_get_worker [#workday_get_worker] Get worker Notes [#notes] * Category: HR & Recruiting * Authentication mode: OAuth # WorkOS Integration The WorkOS integration provides access to manage WorkOS organizations, AuthKit users, memberships, and directory sync through the Integrate MCP server. Installation [#installation] The WorkOS integration is included with the SDK: ```typescript import { workosIntegration } from "integrate-sdk/server"; ``` Setup [#setup] Add WorkOS to your server configuration. Provide credentials via environment variables or integration config: ```typescript import { createMCPServer, workosIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ workosIntegration({ // See configuration options below }), ], }); ``` Client-Side Usage [#client-side-usage] ```typescript import { client } from "integrate-sdk"; const result = await client.workos.listOrganizations({}); console.log(result); ``` Environment Variables [#environment-variables] * `WORKOS_API_KEY` (when supported by this integration) Configuration Options [#configuration-options] Tools [#tools] workos_list_organizations [#workos_list_organizations] List organizations workos_get_organization [#workos_get_organization] Get organization workos_create_organization [#workos_create_organization] Create organization workos_update_organization [#workos_update_organization] Update organization workos_list_users [#workos_list_users] List users workos_get_user [#workos_get_user] Get user workos_list_organization_memberships [#workos_list_organization_memberships] List organization memberships workos_list_directories [#workos_list_directories] List directories workos_get_directory [#workos_get_directory] Get directory workos_list_directory_users [#workos_list_directory_users] List directory users workos_get_directory_user [#workos_get_directory_user] Get directory user Notes [#notes] * Category: Identity & Access * Authentication mode: API key # X Integration The X integration provides access to manage X users, posts, timelines, likes, bookmarks, follows, and posting through the Integrate MCP server. Installation [#installation] The X integration is included with the SDK: ```typescript import { xIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a X OAuth App [#1-create-a-x-oauth-app] 1. Create an OAuth application for X 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the X integration to your server configuration. The integration automatically reads `X_CLIENT_ID` and `X_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, xIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ xIntegration({ scopes: ["tweet.read", "tweet.write", "users.read", "follows.read", "follows.write", "like.read", "like.write", "bookmark.read", "bookmark.write", "offline.access"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript xIntegration({ clientId: process.env.CUSTOM_X_ID, clientSecret: process.env.CUSTOM_X_SECRET, scopes: ["tweet.read", "tweet.write", "users.read", "follows.read", "follows.write", "like.read", "like.write", "bookmark.read", "bookmark.write", "offline.access"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("x"); const result = await client.x.getMe({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, xIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [xIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `tweet.read` * `tweet.write` * `users.read` * `follows.read` * `follows.write` * `like.read` * `like.write` * `bookmark.read` * `bookmark.write` * `offline.access` Tools [#tools] x_get_me [#x_get_me] Get me x_get_user [#x_get_user] Get user x_search_posts [#x_search_posts] Search posts x_get_user_timeline [#x_get_user_timeline] Get user timeline x_create_post [#x_create_post] Create post x_delete_post [#x_delete_post] Delete post x_like_post [#x_like_post] Like post x_get_bookmarks [#x_get_bookmarks] Get bookmarks x_follow_user [#x_follow_user] Follow user Notes [#notes] * Category: Social Media * Authentication mode: OAuth # Xero Integration The Xero integration provides access to manage Xero organisations, accounts, contacts, invoices, and bank transactions through the Integrate MCP server. Installation [#installation] The Xero integration is included with the SDK: ```typescript import { xeroIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Xero OAuth App [#1-create-a-xero-oauth-app] 1. Go to [Login Developer Portal](https://login.xero.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Xero integration to your server configuration. The integration automatically reads `XERO_CLIENT_ID` and `XERO_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, xeroIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ xeroIntegration({ scopes: ["openid", "profile", "email", "offline_access", "accounting.settings", "accounting.transactions", "accounting.contacts", "accounting.attachments"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript xeroIntegration({ clientId: process.env.CUSTOM_XERO_ID, clientSecret: process.env.CUSTOM_XERO_SECRET, scopes: ["openid", "profile", "email", "offline_access", "accounting.settings", "accounting.transactions", "accounting.contacts", "accounting.attachments"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("xero"); const result = await client.xero.listConnections({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, xeroIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [xeroIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `openid` * `profile` * `email` * `offline_access` * `accounting.settings` * `accounting.transactions` * `accounting.contacts` * `accounting.attachments` Tools [#tools] xero_list_connections [#xero_list_connections] List connections *No parameters.* xero_get_organisation [#xero_get_organisation] Get organisation xero_list_accounts [#xero_list_accounts] List accounts xero_list_contacts [#xero_list_contacts] List contacts xero_get_contact [#xero_get_contact] Get contact xero_create_contact [#xero_create_contact] Create contact xero_list_invoices [#xero_list_invoices] List invoices xero_get_invoice [#xero_get_invoice] Get invoice xero_create_invoice [#xero_create_invoice] Create invoice xero_list_bank_transactions [#xero_list_bank_transactions] List bank transactions Notes [#notes] * Category: Accounting * Authentication mode: OAuth # YouTube Integration The YouTube integration provides access to search and access YouTube videos and channels through the Integrate MCP server. Installation [#installation] The YouTube integration is included with the SDK: ```typescript import { youtubeIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a YouTube OAuth App [#1-create-a-youtube-oauth-app] 1. Go to [Google Cloud Console](https://console.cloud.google.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the YouTube integration to your server configuration. The integration automatically reads `YOUTUBE_CLIENT_ID` and `YOUTUBE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, youtubeIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ youtubeIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript youtubeIntegration({ clientId: process.env.CUSTOM_YOUTUBE_ID, clientSecret: process.env.CUSTOM_YOUTUBE_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("youtube"); const result = await client.youtube.search({ query: "value", }); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, youtubeIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [youtubeIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] youtube_add_comment [#youtube_add_comment] Post a new top-level comment on a video youtube_add_to_playlist [#youtube_add_to_playlist] Add a video to a playlist youtube_create_playlist [#youtube_create_playlist] Create a new playlist youtube_delete_playlist [#youtube_delete_playlist] Permanently delete a playlist youtube_get_captions [#youtube_get_captions] List available caption tracks for a video youtube_get_channel [#youtube_get_channel] Get details for any channel by ID youtube_get_my_channel [#youtube_get_my_channel] Get the authenticated user's own channel *No parameters.* youtube_get_playlist [#youtube_get_playlist] Get details for a specific playlist youtube_get_video [#youtube_get_video] Get full details for a specific video youtube_get_video_rating [#youtube_get_video_rating] Get the authenticated user's rating for one or more videos youtube_list_comment_replies [#youtube_list_comment_replies] List replies to a specific comment thread youtube_list_comments [#youtube_list_comments] List top-level comment threads on a video youtube_list_my_videos [#youtube_list_my_videos] List videos uploaded by the authenticated user youtube_list_playlist_items [#youtube_list_playlist_items] List videos in a playlist youtube_list_playlists [#youtube_list_playlists] List playlists for the authenticated user or a specific channel youtube_list_subscriptions [#youtube_list_subscriptions] List channels the authenticated user is subscribed to youtube_rate_video [#youtube_rate_video] Like, dislike, or remove a rating from a video youtube_remove_from_playlist [#youtube_remove_from_playlist] Remove an item from a playlist youtube_reply_to_comment [#youtube_reply_to_comment] Reply to an existing comment thread youtube_search [#youtube_search] Search for videos, channels, or playlists youtube_subscribe [#youtube_subscribe] Subscribe to a channel youtube_unsubscribe [#youtube_unsubscribe] Unsubscribe from a channel youtube_update_playlist [#youtube_update_playlist] Update a playlist's metadata youtube_update_video [#youtube_update_video] Update a video's metadata Notes [#notes] * Category: Entertainment * Authentication mode: OAuth # Zapier Integration The Zapier integration provides access to list Zaps, browse apps, manage authentications, and inspect Zap runs via the Partner Workflow API through the Integrate MCP server. Installation [#installation] The Zapier integration is included with the SDK: ```typescript import { zapierIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zapier OAuth App [#1-create-a-zapier-oauth-app] 1. Go to [Zapier Developer Portal](https://zapier.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zapier integration to your server configuration. The integration automatically reads `ZAPIER_CLIENT_ID` and `ZAPIER_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zapierIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zapierIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zapierIntegration({ clientId: process.env.CUSTOM_ZAPIER_ID, clientSecret: process.env.CUSTOM_ZAPIER_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zapier"); const result = await client.zapier.getProfile({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zapierIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zapierIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] zapier_get_profile [#zapier_get_profile] Get profile *No parameters.* zapier_list_zaps [#zapier_list_zaps] List zaps zapier_list_apps [#zapier_list_apps] List apps zapier_list_actions [#zapier_list_actions] List actions zapier_list_authentications [#zapier_list_authentications] List authentications zapier_list_zap_runs [#zapier_list_zap_runs] List zap runs Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Zendesk Integration The Zendesk integration provides access to manage Zendesk tickets, users, and help center content through the Integrate MCP server. Installation [#installation] The Zendesk integration is included with the SDK: ```typescript import { zendeskIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zendesk OAuth App [#1-create-a-zendesk-oauth-app] 1. Create an OAuth application for Zendesk 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zendesk integration to your server configuration. The integration automatically reads `ZENDESK_CLIENT_ID` and `ZENDESK_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zendeskIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zendeskIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zendeskIntegration({ clientId: process.env.CUSTOM_ZENDESK_ID, clientSecret: process.env.CUSTOM_ZENDESK_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zendesk"); const result = await client.zendesk.listTickets({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zendeskIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zendeskIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] zendesk_list_tickets [#zendesk_list_tickets] List tickets zendesk_get_ticket [#zendesk_get_ticket] Get a specific ticket zendesk_create_ticket [#zendesk_create_ticket] Create a new ticket zendesk_update_ticket [#zendesk_update_ticket] Update an existing ticket zendesk_delete_ticket [#zendesk_delete_ticket] Delete a ticket zendesk_add_comment [#zendesk_add_comment] Add a comment to a ticket zendesk_list_ticket_comments [#zendesk_list_ticket_comments] List comments on a ticket zendesk_list_users [#zendesk_list_users] List users zendesk_get_user [#zendesk_get_user] Get a specific user zendesk_create_user [#zendesk_create_user] Create a new user zendesk_update_user [#zendesk_update_user] Update an existing user zendesk_search_users [#zendesk_search_users] Search for users zendesk_list_organizations [#zendesk_list_organizations] List organizations zendesk_get_organization [#zendesk_get_organization] Get a specific organization zendesk_create_organization [#zendesk_create_organization] Create a new organization zendesk_update_organization [#zendesk_update_organization] Update an existing organization zendesk_list_groups [#zendesk_list_groups] List groups zendesk_get_group [#zendesk_get_group] Get a specific group zendesk_search_tickets [#zendesk_search_tickets] Search for tickets zendesk_search [#zendesk_search] Search across all Zendesk resources (tickets, users, organizations) zendesk_list_views [#zendesk_list_views] List views zendesk_get_view_tickets [#zendesk_get_view_tickets] Get tickets from a specific view zendesk_list_macros [#zendesk_list_macros] List macros zendesk_list_tags [#zendesk_list_tags] List tags *No parameters.* zendesk_add_tags [#zendesk_add_tags] Add tags to a ticket zendesk_remove_tags [#zendesk_remove_tags] Remove tags from a ticket Notes [#notes] * Category: Business * Authentication mode: OAuth # Zoho Analytics Integration The Zoho Analytics integration provides access to manage Zoho Analytics workspaces, views, imports, exports, and query APIs through the Integrate MCP server. Installation [#installation] The Zoho Analytics integration is included with the SDK: ```typescript import { zohoAnalyticsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho Analytics OAuth App [#1-create-a-zoho-analytics-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho Analytics integration to your server configuration. The integration automatically reads `ZOHO_ANALYTICS_CLIENT_ID` and `ZOHO_ANALYTICS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoAnalyticsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoAnalyticsIntegration({ scopes: ["ZohoAnalytics.fullaccess.all"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoAnalyticsIntegration({ clientId: process.env.CUSTOM_ZOHO_ANALYTICS_ID, clientSecret: process.env.CUSTOM_ZOHO_ANALYTICS_SECRET, scopes: ["ZohoAnalytics.fullaccess.all"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_analytics"); const result = await client.zoho_analytics.listWorkspaces({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoAnalyticsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoAnalyticsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoAnalytics.fullaccess.all` Tools [#tools] zoho_analytics_list_workspaces [#zoho_analytics_list_workspaces] Analytics list workspaces *No parameters.* zoho_analytics_get_workspace [#zoho_analytics_get_workspace] Analytics get workspace zoho_analytics_list_views [#zoho_analytics_list_views] Analytics list views zoho_analytics_export_view [#zoho_analytics_export_view] Analytics export view zoho_analytics_import_data [#zoho_analytics_import_data] Analytics import data zoho_analytics_query [#zoho_analytics_query] Analytics query Notes [#notes] * Category: Analytics * Authentication mode: OAuth # Zoho Billing Integration The Zoho Billing integration provides access to manage Zoho Billing organizations, customers, items, subscriptions, and invoices through the Integrate MCP server. Installation [#installation] The Zoho Billing integration is included with the SDK: ```typescript import { zohoBillingIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho Billing OAuth App [#1-create-a-zoho-billing-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho Billing integration to your server configuration. The integration automatically reads `ZOHO_BILLING_CLIENT_ID` and `ZOHO_BILLING_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoBillingIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoBillingIntegration({ scopes: ["ZohoBilling.fullaccess.all"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoBillingIntegration({ clientId: process.env.CUSTOM_ZOHO_BILLING_ID, clientSecret: process.env.CUSTOM_ZOHO_BILLING_SECRET, scopes: ["ZohoBilling.fullaccess.all"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_billing"); const result = await client.zoho_billing.listOrganizations({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoBillingIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoBillingIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoBilling.fullaccess.all` Tools [#tools] zoho_billing_list_organizations [#zoho_billing_list_organizations] Billing list organizations *No parameters.* zoho_billing_list_customers [#zoho_billing_list_customers] Billing list customers zoho_billing_list_items [#zoho_billing_list_items] Billing list items zoho_billing_list_subscriptions [#zoho_billing_list_subscriptions] Billing list subscriptions zoho_billing_create_subscription [#zoho_billing_create_subscription] Billing create subscription zoho_billing_list_invoices [#zoho_billing_list_invoices] Billing list invoices Notes [#notes] * Category: Accounting * Authentication mode: OAuth # Zoho Books Integration The Zoho Books integration provides access to manage Zoho Books organizations, contacts, items, invoices, bills, payments, and reports through the Integrate MCP server. Installation [#installation] The Zoho Books integration is included with the SDK: ```typescript import { zohoBooksIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho Books OAuth App [#1-create-a-zoho-books-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho Books integration to your server configuration. The integration automatically reads `ZOHO_BOOKS_CLIENT_ID` and `ZOHO_BOOKS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoBooksIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoBooksIntegration({ scopes: ["ZohoBooks.fullaccess.all"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoBooksIntegration({ clientId: process.env.CUSTOM_ZOHO_BOOKS_ID, clientSecret: process.env.CUSTOM_ZOHO_BOOKS_SECRET, scopes: ["ZohoBooks.fullaccess.all"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_books"); const result = await client.zoho_books.listOrganizations({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoBooksIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoBooksIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoBooks.fullaccess.all` Tools [#tools] zoho_books_list_organizations [#zoho_books_list_organizations] Books list organizations zoho_books_list_contacts [#zoho_books_list_contacts] Books list contacts zoho_books_list_items [#zoho_books_list_items] Books list items zoho_books_list_invoices [#zoho_books_list_invoices] Books list invoices zoho_books_list_bills [#zoho_books_list_bills] Books list bills zoho_books_list_customerpayments [#zoho_books_list_customerpayments] Books list customerpayments zoho_books_create_invoice [#zoho_books_create_invoice] Books create invoice zoho_books_profit_and_loss [#zoho_books_profit_and_loss] Books profit and loss Notes [#notes] * Category: Accounting * Authentication mode: OAuth # Zoho Campaigns Integration The Zoho Campaigns integration provides access to manage Zoho Campaigns lists, contacts, campaigns, reports, and sends through the Integrate MCP server. Installation [#installation] The Zoho Campaigns integration is included with the SDK: ```typescript import { zohoCampaignsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho Campaigns OAuth App [#1-create-a-zoho-campaigns-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho Campaigns integration to your server configuration. The integration automatically reads `ZOHO_CAMPAIGNS_CLIENT_ID` and `ZOHO_CAMPAIGNS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoCampaignsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoCampaignsIntegration({ scopes: ["ZohoCampaigns.campaign.ALL", "ZohoCampaigns.contact.ALL", "ZohoCampaigns.report.READ"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoCampaignsIntegration({ clientId: process.env.CUSTOM_ZOHO_CAMPAIGNS_ID, clientSecret: process.env.CUSTOM_ZOHO_CAMPAIGNS_SECRET, scopes: ["ZohoCampaigns.campaign.ALL", "ZohoCampaigns.contact.ALL", "ZohoCampaigns.report.READ"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_campaigns"); const result = await client.zoho_campaigns.listMailingLists({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoCampaignsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoCampaignsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoCampaigns.campaign.ALL` * `ZohoCampaigns.contact.ALL` * `ZohoCampaigns.report.READ` Tools [#tools] zoho_campaigns_list_mailing_lists [#zoho_campaigns_list_mailing_lists] Campaigns list mailing lists *No parameters.* zoho_campaigns_list_contacts [#zoho_campaigns_list_contacts] Campaigns list contacts zoho_campaigns_add_contact [#zoho_campaigns_add_contact] Campaigns add contact zoho_campaigns_list_campaigns [#zoho_campaigns_list_campaigns] Campaigns list campaigns zoho_campaigns_get_campaign_report [#zoho_campaigns_get_campaign_report] Campaigns get campaign report zoho_campaigns_send_campaign [#zoho_campaigns_send_campaign] Campaigns send campaign Notes [#notes] * Category: Marketing * Authentication mode: OAuth # Zoho Creator Integration The Zoho Creator integration provides access to manage Zoho Creator applications, forms, reports, and app records through the Integrate MCP server. Installation [#installation] The Zoho Creator integration is included with the SDK: ```typescript import { zohoCreatorIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho Creator OAuth App [#1-create-a-zoho-creator-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho Creator integration to your server configuration. The integration automatically reads `ZOHO_CREATOR_CLIENT_ID` and `ZOHO_CREATOR_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoCreatorIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoCreatorIntegration({ scopes: ["ZohoCreator.meta.READ", "ZohoCreator.data.READ", "ZohoCreator.data.CREATE", "ZohoCreator.data.UPDATE"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoCreatorIntegration({ clientId: process.env.CUSTOM_ZOHO_CREATOR_ID, clientSecret: process.env.CUSTOM_ZOHO_CREATOR_SECRET, scopes: ["ZohoCreator.meta.READ", "ZohoCreator.data.READ", "ZohoCreator.data.CREATE", "ZohoCreator.data.UPDATE"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_creator"); const result = await client.zoho_creator.listApplications({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoCreatorIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoCreatorIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoCreator.meta.READ` * `ZohoCreator.data.READ` * `ZohoCreator.data.CREATE` * `ZohoCreator.data.UPDATE` Tools [#tools] zoho_creator_list_applications [#zoho_creator_list_applications] Creator list applications zoho_creator_list_forms [#zoho_creator_list_forms] Creator list forms zoho_creator_list_reports [#zoho_creator_list_reports] Creator list reports zoho_creator_list_records [#zoho_creator_list_records] Creator list records zoho_creator_create_record [#zoho_creator_create_record] Creator create record zoho_creator_update_record [#zoho_creator_update_record] Creator update record Notes [#notes] * Category: Business * Authentication mode: OAuth # Zoho CRM Integration The Zoho CRM integration provides access to manage Zoho CRM modules, records, users, org settings, search, and COQL through the Integrate MCP server. Installation [#installation] The Zoho CRM integration is included with the SDK: ```typescript import { zohoCrmIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho CRM OAuth App [#1-create-a-zoho-crm-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho CRM integration to your server configuration. The integration automatically reads `ZOHO_CRM_CLIENT_ID` and `ZOHO_CRM_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoCrmIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoCrmIntegration({ scopes: ["ZohoCRM.modules.ALL", "ZohoCRM.settings.ALL", "ZohoCRM.users.ALL"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoCrmIntegration({ clientId: process.env.CUSTOM_ZOHO_CRM_ID, clientSecret: process.env.CUSTOM_ZOHO_CRM_SECRET, scopes: ["ZohoCRM.modules.ALL", "ZohoCRM.settings.ALL", "ZohoCRM.users.ALL"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_crm"); const result = await client.zoho_crm.listModules({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoCrmIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoCrmIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoCRM.modules.ALL` * `ZohoCRM.settings.ALL` * `ZohoCRM.users.ALL` Tools [#tools] zoho_crm_list_modules [#zoho_crm_list_modules] Crm list modules *No parameters.* zoho_crm_list_records [#zoho_crm_list_records] Crm list records zoho_crm_get_record [#zoho_crm_get_record] Crm get record zoho_crm_create_records [#zoho_crm_create_records] Crm create records zoho_crm_update_record [#zoho_crm_update_record] Crm update record zoho_crm_search_records [#zoho_crm_search_records] Crm search records zoho_crm_coql_query [#zoho_crm_coql_query] Crm coql query zoho_crm_list_users [#zoho_crm_list_users] Crm list users zoho_crm_get_org [#zoho_crm_get_org] Crm get org *No parameters.* Notes [#notes] * Category: Business * Authentication mode: OAuth # Zoho Desk Integration The Zoho Desk integration provides access to manage Zoho Desk tickets, contacts, accounts, agents, departments, and articles through the Integrate MCP server. Installation [#installation] The Zoho Desk integration is included with the SDK: ```typescript import { zohoDeskIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho Desk OAuth App [#1-create-a-zoho-desk-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho Desk integration to your server configuration. The integration automatically reads `ZOHO_DESK_CLIENT_ID` and `ZOHO_DESK_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoDeskIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoDeskIntegration({ scopes: ["Desk.tickets.ALL", "Desk.contacts.ALL", "Desk.settings.READ"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoDeskIntegration({ clientId: process.env.CUSTOM_ZOHO_DESK_ID, clientSecret: process.env.CUSTOM_ZOHO_DESK_SECRET, scopes: ["Desk.tickets.ALL", "Desk.contacts.ALL", "Desk.settings.READ"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_desk"); const result = await client.zoho_desk.listTickets({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoDeskIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoDeskIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `Desk.tickets.ALL` * `Desk.contacts.ALL` * `Desk.settings.READ` Tools [#tools] zoho_desk_list_tickets [#zoho_desk_list_tickets] Desk list tickets zoho_desk_get_ticket [#zoho_desk_get_ticket] Desk get ticket zoho_desk_create_ticket [#zoho_desk_create_ticket] Desk create ticket zoho_desk_list_contacts [#zoho_desk_list_contacts] Desk list contacts zoho_desk_list_accounts [#zoho_desk_list_accounts] Desk list accounts zoho_desk_list_agents [#zoho_desk_list_agents] Desk list agents *No parameters.* zoho_desk_list_departments [#zoho_desk_list_departments] Desk list departments *No parameters.* zoho_desk_search_articles [#zoho_desk_search_articles] Desk search articles Notes [#notes] * Category: Business * Authentication mode: OAuth # Zoho Inventory Integration The Zoho Inventory integration provides access to manage Zoho Inventory organizations, contacts, items, sales orders, packages, and shipments through the Integrate MCP server. Installation [#installation] The Zoho Inventory integration is included with the SDK: ```typescript import { zohoInventoryIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho Inventory OAuth App [#1-create-a-zoho-inventory-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho Inventory integration to your server configuration. The integration automatically reads `ZOHO_INVENTORY_CLIENT_ID` and `ZOHO_INVENTORY_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoInventoryIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoInventoryIntegration({ scopes: ["ZohoInventory.fullaccess.all"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoInventoryIntegration({ clientId: process.env.CUSTOM_ZOHO_INVENTORY_ID, clientSecret: process.env.CUSTOM_ZOHO_INVENTORY_SECRET, scopes: ["ZohoInventory.fullaccess.all"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_inventory"); const result = await client.zoho_inventory.listOrganizations({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoInventoryIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoInventoryIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoInventory.fullaccess.all` Tools [#tools] zoho_inventory_list_organizations [#zoho_inventory_list_organizations] Inventory list organizations *No parameters.* zoho_inventory_list_contacts [#zoho_inventory_list_contacts] Inventory list contacts zoho_inventory_list_items [#zoho_inventory_list_items] Inventory list items zoho_inventory_list_sales_orders [#zoho_inventory_list_sales_orders] Inventory list sales orders zoho_inventory_create_sales_order [#zoho_inventory_create_sales_order] Inventory create sales order zoho_inventory_list_packages [#zoho_inventory_list_packages] Inventory list packages Notes [#notes] * Category: Commerce * Authentication mode: OAuth # Zoho Invoice Integration The Zoho Invoice integration provides access to manage Zoho Invoice organizations, customers, items, estimates, invoices, payments, and reports through the Integrate MCP server. Installation [#installation] The Zoho Invoice integration is included with the SDK: ```typescript import { zohoInvoiceIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho Invoice OAuth App [#1-create-a-zoho-invoice-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho Invoice integration to your server configuration. The integration automatically reads `ZOHO_INVOICE_CLIENT_ID` and `ZOHO_INVOICE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoInvoiceIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoInvoiceIntegration({ scopes: ["ZohoInvoice.fullaccess.all"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoInvoiceIntegration({ clientId: process.env.CUSTOM_ZOHO_INVOICE_ID, clientSecret: process.env.CUSTOM_ZOHO_INVOICE_SECRET, scopes: ["ZohoInvoice.fullaccess.all"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_invoice"); const result = await client.zoho_invoice.listOrganizations({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoInvoiceIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoInvoiceIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoInvoice.fullaccess.all` Tools [#tools] zoho_invoice_list_organizations [#zoho_invoice_list_organizations] Invoice list organizations zoho_invoice_list_contacts [#zoho_invoice_list_contacts] Invoice list contacts zoho_invoice_list_items [#zoho_invoice_list_items] Invoice list items zoho_invoice_list_estimates [#zoho_invoice_list_estimates] Invoice list estimates zoho_invoice_list_invoices [#zoho_invoice_list_invoices] Invoice list invoices zoho_invoice_list_customerpayments [#zoho_invoice_list_customerpayments] Invoice list customerpayments zoho_invoice_create_invoice [#zoho_invoice_create_invoice] Invoice create invoice zoho_invoice_get_aging_summary [#zoho_invoice_get_aging_summary] Invoice get aging summary Notes [#notes] * Category: Accounting * Authentication mode: OAuth # Zoho Mail Integration The Zoho Mail integration provides access to manage Zoho Mail accounts, folders, messages, labels, search, and sending through the Integrate MCP server. Installation [#installation] The Zoho Mail integration is included with the SDK: ```typescript import { zohoMailIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho Mail OAuth App [#1-create-a-zoho-mail-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho Mail integration to your server configuration. The integration automatically reads `ZOHO_MAIL_CLIENT_ID` and `ZOHO_MAIL_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoMailIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoMailIntegration({ scopes: ["ZohoMail.accounts.READ", "ZohoMail.messages.ALL", "ZohoMail.folders.ALL"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoMailIntegration({ clientId: process.env.CUSTOM_ZOHO_MAIL_ID, clientSecret: process.env.CUSTOM_ZOHO_MAIL_SECRET, scopes: ["ZohoMail.accounts.READ", "ZohoMail.messages.ALL", "ZohoMail.folders.ALL"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_mail"); const result = await client.zoho_mail.listAccounts({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoMailIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoMailIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoMail.accounts.READ` * `ZohoMail.messages.ALL` * `ZohoMail.folders.ALL` Tools [#tools] zoho_mail_list_accounts [#zoho_mail_list_accounts] Mail list accounts *No parameters.* zoho_mail_list_folders [#zoho_mail_list_folders] Mail list folders zoho_mail_list_messages [#zoho_mail_list_messages] Mail list messages zoho_mail_get_message [#zoho_mail_get_message] Mail get message zoho_mail_send_message [#zoho_mail_send_message] Mail send message zoho_mail_search_messages [#zoho_mail_search_messages] Mail search messages zoho_mail_list_labels [#zoho_mail_list_labels] Mail list labels Notes [#notes] * Category: Communication * Authentication mode: OAuth # Zoho People Integration The Zoho People integration provides access to manage Zoho People forms, employees, attendance, leave requests, and time tracking through the Integrate MCP server. Installation [#installation] The Zoho People integration is included with the SDK: ```typescript import { zohoPeopleIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho People OAuth App [#1-create-a-zoho-people-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho People integration to your server configuration. The integration automatically reads `ZOHO_PEOPLE_CLIENT_ID` and `ZOHO_PEOPLE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoPeopleIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoPeopleIntegration({ scopes: ["ZohoPeople.forms.ALL", "ZohoPeople.employee.ALL", "ZohoPeople.leave.ALL", "ZohoPeople.attendance.ALL"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoPeopleIntegration({ clientId: process.env.CUSTOM_ZOHO_PEOPLE_ID, clientSecret: process.env.CUSTOM_ZOHO_PEOPLE_SECRET, scopes: ["ZohoPeople.forms.ALL", "ZohoPeople.employee.ALL", "ZohoPeople.leave.ALL", "ZohoPeople.attendance.ALL"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_people"); const result = await client.zoho_people.listForms({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoPeopleIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoPeopleIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoPeople.forms.ALL` * `ZohoPeople.employee.ALL` * `ZohoPeople.leave.ALL` * `ZohoPeople.attendance.ALL` Tools [#tools] zoho_people_list_forms [#zoho_people_list_forms] People list forms *No parameters.* zoho_people_list_employees [#zoho_people_list_employees] People list employees zoho_people_get_employee [#zoho_people_get_employee] People get employee zoho_people_list_attendance [#zoho_people_list_attendance] People list attendance zoho_people_list_leave_requests [#zoho_people_list_leave_requests] People list leave requests zoho_people_list_time_logs [#zoho_people_list_time_logs] People list time logs Notes [#notes] * Category: HR & Recruiting * Authentication mode: OAuth # Zoho Projects Integration The Zoho Projects integration provides access to manage Zoho Projects portals, projects, milestones, tasks, issues, and timesheets through the Integrate MCP server. Installation [#installation] The Zoho Projects integration is included with the SDK: ```typescript import { zohoProjectsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho Projects OAuth App [#1-create-a-zoho-projects-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho Projects integration to your server configuration. The integration automatically reads `ZOHO_PROJECTS_CLIENT_ID` and `ZOHO_PROJECTS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoProjectsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoProjectsIntegration({ scopes: ["ZohoProjects.portals.ALL", "ZohoProjects.projects.ALL", "ZohoProjects.tasks.ALL", "ZohoProjects.issues.ALL"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoProjectsIntegration({ clientId: process.env.CUSTOM_ZOHO_PROJECTS_ID, clientSecret: process.env.CUSTOM_ZOHO_PROJECTS_SECRET, scopes: ["ZohoProjects.portals.ALL", "ZohoProjects.projects.ALL", "ZohoProjects.tasks.ALL", "ZohoProjects.issues.ALL"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_projects"); const result = await client.zoho_projects.listPortals({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoProjectsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoProjectsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoProjects.portals.ALL` * `ZohoProjects.projects.ALL` * `ZohoProjects.tasks.ALL` * `ZohoProjects.issues.ALL` Tools [#tools] zoho_projects_list_portals [#zoho_projects_list_portals] Projects list portals *No parameters.* zoho_projects_list_projects [#zoho_projects_list_projects] Projects list projects zoho_projects_get_project [#zoho_projects_get_project] Projects get project zoho_projects_list_milestones [#zoho_projects_list_milestones] Projects list milestones zoho_projects_list_tasklists [#zoho_projects_list_tasklists] Projects list tasklists zoho_projects_list_tasks [#zoho_projects_list_tasks] Projects list tasks zoho_projects_create_task [#zoho_projects_create_task] Projects create task zoho_projects_list_issues [#zoho_projects_list_issues] Projects list issues zoho_projects_list_timesheets [#zoho_projects_list_timesheets] Projects list timesheets Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Zoho Recruit Integration The Zoho Recruit integration provides access to manage Zoho Recruit candidates, job openings, interviews, and custom modules through the Integrate MCP server. Installation [#installation] The Zoho Recruit integration is included with the SDK: ```typescript import { zohoRecruitIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho Recruit OAuth App [#1-create-a-zoho-recruit-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho Recruit integration to your server configuration. The integration automatically reads `ZOHO_RECRUIT_CLIENT_ID` and `ZOHO_RECRUIT_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoRecruitIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoRecruitIntegration({ scopes: ["ZohoRecruit.modules.ALL", "ZohoRecruit.settings.ALL"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoRecruitIntegration({ clientId: process.env.CUSTOM_ZOHO_RECRUIT_ID, clientSecret: process.env.CUSTOM_ZOHO_RECRUIT_SECRET, scopes: ["ZohoRecruit.modules.ALL", "ZohoRecruit.settings.ALL"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_recruit"); const result = await client.zoho_recruit.listModules({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoRecruitIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoRecruitIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoRecruit.modules.ALL` * `ZohoRecruit.settings.ALL` Tools [#tools] zoho_recruit_list_modules [#zoho_recruit_list_modules] Recruit list modules *No parameters.* zoho_recruit_list_candidates [#zoho_recruit_list_candidates] Recruit list candidates zoho_recruit_get_candidate [#zoho_recruit_get_candidate] Recruit get candidate zoho_recruit_create_candidate [#zoho_recruit_create_candidate] Recruit create candidate zoho_recruit_list_job_openings [#zoho_recruit_list_job_openings] Recruit list job openings zoho_recruit_list_interviews [#zoho_recruit_list_interviews] Recruit list interviews Notes [#notes] * Category: HR & Recruiting * Authentication mode: OAuth # Zoho Sign Integration The Zoho Sign integration provides access to manage Zoho Sign requests, templates, contacts, and signature workflows through the Integrate MCP server. Installation [#installation] The Zoho Sign integration is included with the SDK: ```typescript import { zohoSignIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho Sign OAuth App [#1-create-a-zoho-sign-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho Sign integration to your server configuration. The integration automatically reads `ZOHO_SIGN_CLIENT_ID` and `ZOHO_SIGN_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoSignIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoSignIntegration({ scopes: ["ZohoSign.documents.ALL", "ZohoSign.templates.READ", "ZohoSign.account.READ"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoSignIntegration({ clientId: process.env.CUSTOM_ZOHO_SIGN_ID, clientSecret: process.env.CUSTOM_ZOHO_SIGN_SECRET, scopes: ["ZohoSign.documents.ALL", "ZohoSign.templates.READ", "ZohoSign.account.READ"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_sign"); const result = await client.zoho_sign.listRequests({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoSignIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoSignIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoSign.documents.ALL` * `ZohoSign.templates.READ` * `ZohoSign.account.READ` Tools [#tools] zoho_sign_list_requests [#zoho_sign_list_requests] Sign list requests zoho_sign_get_request [#zoho_sign_get_request] Sign get request zoho_sign_create_request [#zoho_sign_create_request] Sign create request zoho_sign_list_templates [#zoho_sign_list_templates] Sign list templates zoho_sign_get_template [#zoho_sign_get_template] Sign get template zoho_sign_list_contacts [#zoho_sign_list_contacts] Sign list contacts Notes [#notes] * Category: Legal * Authentication mode: OAuth # Zoho Sprints Integration The Zoho Sprints integration provides access to manage Zoho Sprints portals, projects, sprints, epics, and work items through the Integrate MCP server. Installation [#installation] The Zoho Sprints integration is included with the SDK: ```typescript import { zohoSprintsIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho Sprints OAuth App [#1-create-a-zoho-sprints-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho Sprints integration to your server configuration. The integration automatically reads `ZOHO_SPRINTS_CLIENT_ID` and `ZOHO_SPRINTS_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoSprintsIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoSprintsIntegration({ scopes: ["ZohoSprints.projects.ALL", "ZohoSprints.sprints.ALL", "ZohoSprints.workitems.ALL", "ZohoSprints.epics.ALL"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoSprintsIntegration({ clientId: process.env.CUSTOM_ZOHO_SPRINTS_ID, clientSecret: process.env.CUSTOM_ZOHO_SPRINTS_SECRET, scopes: ["ZohoSprints.projects.ALL", "ZohoSprints.sprints.ALL", "ZohoSprints.workitems.ALL", "ZohoSprints.epics.ALL"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_sprints"); const result = await client.zoho_sprints.listPortals({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoSprintsIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoSprintsIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoSprints.projects.ALL` * `ZohoSprints.sprints.ALL` * `ZohoSprints.workitems.ALL` * `ZohoSprints.epics.ALL` Tools [#tools] zoho_sprints_list_portals [#zoho_sprints_list_portals] Sprints list portals *No parameters.* zoho_sprints_list_projects [#zoho_sprints_list_projects] Sprints list projects zoho_sprints_list_sprints [#zoho_sprints_list_sprints] Sprints list sprints zoho_sprints_list_work_items [#zoho_sprints_list_work_items] Sprints list work items zoho_sprints_create_work_item [#zoho_sprints_create_work_item] Sprints create work item zoho_sprints_list_epics [#zoho_sprints_list_epics] Sprints list epics Notes [#notes] * Category: Engineering * Authentication mode: OAuth # Zoho WorkDrive Integration The Zoho WorkDrive integration provides access to manage Zoho WorkDrive team folders, files, folders, and collaborators through the Integrate MCP server. Installation [#installation] The Zoho WorkDrive integration is included with the SDK: ```typescript import { zohoWorkdriveIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho WorkDrive OAuth App [#1-create-a-zoho-workdrive-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho WorkDrive integration to your server configuration. The integration automatically reads `ZOHO_WORKDRIVE_CLIENT_ID` and `ZOHO_WORKDRIVE_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoWorkdriveIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoWorkdriveIntegration({ scopes: ["WorkDrive.files.ALL", "WorkDrive.teamfolders.READ", "WorkDrive.users.READ"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoWorkdriveIntegration({ clientId: process.env.CUSTOM_ZOHO_WORKDRIVE_ID, clientSecret: process.env.CUSTOM_ZOHO_WORKDRIVE_SECRET, scopes: ["WorkDrive.files.ALL", "WorkDrive.teamfolders.READ", "WorkDrive.users.READ"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_workdrive"); const result = await client.zoho_workdrive.listTeams({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoWorkdriveIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoWorkdriveIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `WorkDrive.files.ALL` * `WorkDrive.teamfolders.READ` * `WorkDrive.users.READ` Tools [#tools] zoho_workdrive_list_teams [#zoho_workdrive_list_teams] Workdrive list teams *No parameters.* zoho_workdrive_list_team_folders [#zoho_workdrive_list_team_folders] Workdrive list team folders zoho_workdrive_get_team_folder [#zoho_workdrive_get_team_folder] Workdrive get team folder zoho_workdrive_list_files [#zoho_workdrive_list_files] Workdrive list files zoho_workdrive_get_file [#zoho_workdrive_get_file] Workdrive get file zoho_workdrive_create_folder [#zoho_workdrive_create_folder] Workdrive create folder Notes [#notes] * Category: Storage * Authentication mode: OAuth # Zoho Writer Integration The Zoho Writer integration provides access to manage Zoho Writer documents, templates, merges, and exports through the Integrate MCP server. Installation [#installation] The Zoho Writer integration is included with the SDK: ```typescript import { zohoWriterIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoho Writer OAuth App [#1-create-a-zoho-writer-oauth-app] 1. Go to [Zoho API Console](https://api-console.zoho.com) 2. Create a new OAuth application 3. Configure your redirect URI 4. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoho Writer integration to your server configuration. The integration automatically reads `ZOHO_WRITER_CLIENT_ID` and `ZOHO_WRITER_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zohoWriterIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zohoWriterIntegration({ scopes: ["ZohoWriter.documentEditor.ALL", "ZohoWriter.merge.ALL"], // Optional }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zohoWriterIntegration({ clientId: process.env.CUSTOM_ZOHO_WRITER_ID, clientSecret: process.env.CUSTOM_ZOHO_WRITER_SECRET, scopes: ["ZohoWriter.documentEditor.ALL", "ZohoWriter.merge.ALL"], // Optional }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoho_writer"); const result = await client.zoho_writer.listDocuments({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zohoWriterIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zohoWriterIntegration()], }); ``` Configuration Options [#configuration-options] Default Scopes [#default-scopes] These defaults are applied unless you override `scopes` in the integration config: * `ZohoWriter.documentEditor.ALL` * `ZohoWriter.merge.ALL` Tools [#tools] zoho_writer_list_documents [#zoho_writer_list_documents] Writer list documents zoho_writer_get_document [#zoho_writer_get_document] Writer get document zoho_writer_create_document [#zoho_writer_create_document] Writer create document zoho_writer_list_templates [#zoho_writer_list_templates] Writer list templates zoho_writer_merge_document [#zoho_writer_merge_document] Writer merge document zoho_writer_export_document [#zoho_writer_export_document] Writer export document Notes [#notes] * Category: Productivity * Authentication mode: OAuth # Zoom Integration The Zoom integration provides access to manage Zoom user profile and meetings through the Integrate MCP server. Installation [#installation] The Zoom integration is included with the SDK: ```typescript import { zoomIntegration } from "integrate-sdk/server"; ``` Setup [#setup] 1. Create a Zoom OAuth App [#1-create-a-zoom-oauth-app] 1. Create an OAuth application for Zoom 2. Configure your redirect URI 3. Note your Client ID and Client Secret 2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server] Add the Zoom integration to your server configuration. The integration automatically reads `ZOOM_CLIENT_ID` and `ZOOM_CLIENT_SECRET` from your environment variables: ```typescript import { createMCPServer, zoomIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ zoomIntegration({ }), ], }); ``` You can override the environment variables by passing explicit values: ```typescript zoomIntegration({ clientId: process.env.CUSTOM_ZOOM_ID, clientSecret: process.env.CUSTOM_ZOOM_SECRET, }); ``` 3. Client-Side Usage [#3-client-side-usage] The default client automatically includes all integrations. You can use it directly: ```typescript import { client } from "integrate-sdk"; await client.authorize("zoom"); const result = await client.zoom.getUser({}); console.log(result); ``` If you're using a custom client, add the integration to the integrations array: ```typescript import { createMCPClient, zoomIntegration } from "integrate-sdk"; const customClient = createMCPClient({ integrations: [zoomIntegration()], }); ``` Configuration Options [#configuration-options] Tools [#tools] zoom_get_user [#zoom_get_user] Get user zoom_list_meetings [#zoom_list_meetings] List meetings zoom_create_meeting [#zoom_create_meeting] Create meeting zoom_get_meeting [#zoom_get_meeting] Get meeting zoom_update_meeting [#zoom_update_meeting] Update meeting zoom_delete_meeting [#zoom_delete_meeting] Delete meeting Notes [#notes] * Category: Communication * Authentication mode: OAuth # Elysia The Integrate SDK provides seamless integration with Elysia through server-side configuration and route handlers. This guide assumes you have an Elysia project already set up. Installation [#installation] Install the Integrate SDK in your Elysia project: ```bash bun add integrate-sdk ``` Setup [#setup] Create a server configuration file with your OAuth credentials: ```typescript // src/index.ts import { Elysia } from "elysia"; import { createMCPServer, githubIntegration } from "integrate-sdk/server"; import { cors } from "@elysiajs/cors"; const app = new Elysia(); const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); app.use( cors({ origin: process.env.FRONTEND_URL || "http://localhost:3000", credentials: true, }) ); app.all("/api/integrate/*", (context) => { return serverClient.handler(context.request); }); app.listen(process.env.PORT || 8080); console.log(`Server running on port ${process.env.PORT || 8080}`); ``` You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash INTEGRATE_API_KEY=your_integrate_api_key GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret FRONTEND_URL=http://localhost:3000 PORT=8080 ``` CORS Setup [#cors-setup] CORS is configured in the setup above. If you need to customize it, adjust the CORS middleware: ```typescript app.use( cors({ origin: process.env.FRONTEND_URL || "http://localhost:3000", credentials: true, }) ); ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` # Express The Integrate SDK provides seamless integration with Express through server-side configuration and route handlers. This guide assumes you have an Express project already set up. Installation [#installation] Install the Integrate SDK in your Express project: ```bash bun add integrate-sdk ``` Setup [#setup] Create a server configuration file with your OAuth credentials: ```typescript // src/index.ts import express from "express"; import { createMCPServer, githubIntegration, } from "integrate-sdk/server"; import cors from "cors"; const app = express(); export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); app.use( cors({ origin: process.env.FRONTEND_URL || "http://localhost:3000", credentials: true, }) ) app.all("/api/integrate/*", (request: Request) => { return serverClient.handler(request); }); app.use(express.json()); app.listen(process.env.PORT || 8080, () => { console.log(`Server running on port ${process.env.PORT || 8080}`); }); ``` Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash INTEGRATE_API_KEY=your_integrate_api_key GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret FRONTEND_URL=http://localhost:3000 PORT=8080 ``` You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). CORS Setup [#cors-setup] CORS is configured in the setup above. If you need to customize it, adjust the CORS middleware: ```typescript app.use( cors({ origin: process.env.FRONTEND_URL || "http://localhost:3000", credentials: true, }) ); ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` # Fastify The Integrate SDK provides seamless integration with Fastify through server-side configuration and route handlers. This guide assumes you have a Fastify project already set up. Installation [#installation] Install the Integrate SDK in your Fastify project: ```bash bun add integrate-sdk ``` Setup [#setup] Create a server configuration file with your OAuth credentials: ```typescript // src/index.ts import Fastify from "fastify"; import cors from "@fastify/cors"; import { createMCPServer, githubIntegration, } from "integrate-sdk/server"; const app = Fastify(); export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); await app.register(cors, { origin: process.env.FRONTEND_URL || "http://localhost:3000", credentials: true, }); app.route({ method: ["GET", "POST"], url: "/api/integrate/*", async handler(request, reply) { try { const url = new URL(request.url, `http://${request.headers.host}`); const headers = new Headers(); Object.entries(request.headers).forEach(([key, value]) => { if (value) headers.append(key, value.toString()); }); const req = new Request(url.toString(), { method: request.method, headers, body: request.body ? JSON.stringify(request.body) : undefined, }); const response = await serverClient.handler(req); if (response) { reply.status(response.status); response.headers.forEach((value: string, key: string) => reply.header(key, value)); reply.send(response.body ? await response.text() : null); } else { reply.status(204).send(); } } catch (error) { reply.status(500).send({ error: "Internal integration error", code: "INTEGRATION_FAILURE" }); } } }); app.listen({ port: Number(process.env.PORT) || 8080 }, () => { console.log(`Server running on port ${process.env.PORT || 8080}`); }); ``` Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash INTEGRATE_API_KEY=your_integrate_api_key GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret FRONTEND_URL=http://localhost:3000 PORT=8080 ``` You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). CORS Setup [#cors-setup] CORS is configured in the setup above. If you need to customize it, adjust the CORS registration: ```typescript await app.register(cors, { origin: process.env.FRONTEND_URL || "http://localhost:3000", credentials: true, }); ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` # Hono The Integrate SDK provides seamless integration with Hono through server-side configuration and route handlers. This guide assumes you have a Hono project already set up. Installation [#installation] Install the Integrate SDK in your Hono project: ```bash bun add integrate-sdk ``` Setup [#setup] Create a server configuration file with your OAuth credentials: ```typescript // src/index.ts import { Hono } from 'hono' import { cors } from 'hono/cors' import { createMCPServer, githubIntegration } from 'integrate-sdk/server'; const app = new Hono() export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); app.use( "/api/integrate/*", cors({ origin: process.env.FRONTEND_URL || "http://localhost:3000", credentials: true, }), ); app.on(["POST", "GET"], "/api/integrate/*", (c) => { return serverClient.handler(c.req.raw); }); export default app ``` You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash INTEGRATE_API_KEY=your_integrate_api_key GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret FRONTEND_URL=http://localhost:3000 PORT=8080 ``` CORS Setup [#cors-setup] CORS is configured in the setup above. If you need to customize it, adjust the CORS middleware: ```typescript app.use( "/api/integrate/*", cors({ origin: process.env.FRONTEND_URL || "http://localhost:3000", credentials: true, }) ); ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` # NestJS The Integrate SDK provides seamless integration with NestJS through server-side configuration and controllers. This guide assumes you have a NestJS project already set up. Installation [#installation] Install the Integrate SDK in your NestJS project: ```bash bun add integrate-sdk ``` Setup [#setup] Server Configuration [#server-configuration] Create a server configuration file with your OAuth credentials: ```typescript // src/integrate.ts import { createMCPServer, githubIntegration } from 'integrate-sdk/server'; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ['repo', 'user'], }), ], }); ``` You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). OAuth Controller [#oauth-controller] Create a controller to handle OAuth routes: ```typescript // src/oauth.controller.ts import { Controller, All, Req, Res } from "@nestjs/common"; import type { Request, Response } from "express"; import { serverClient } from "./integrate"; @Controller("api/integrate") export class OAuthController { @All("*") async handleOAuth(@Req() req: Request, @Res() res: Response) { await serverClient.handler(req, res); } } ``` Register the controller in your module: ```typescript // src/app.module.ts import { Module } from '@nestjs/common'; import { AppController } from './app.controller'; import { AppService } from './app.service'; import { OAuthController } from './oauth.controller'; @Module({ imports: [], controllers: [AppController, OAuthController], providers: [AppService], }) export class AppModule { } ``` Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash INTEGRATE_API_KEY=your_integrate_api_key GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret FRONTEND_URL=http://localhost:3000 PORT=8080 ``` CORS Setup [#cors-setup] Configure CORS in your `main.ts`: ```typescript // src/main.ts import { NestFactory } from '@nestjs/core'; import { AppModule } from './app.module'; async function bootstrap() { const app = await NestFactory.create(AppModule, { bodyParser: false, }); app.enableCors({ origin: process.env.FRONTEND_URL || "http://localhost:3000", credentials: true, }); await app.listen(process.env.PORT ?? 8080); } bootstrap().catch(console.error); ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` # Nitro The Integrate SDK provides seamless integration with Nitro through server-side configuration and route handlers. This guide assumes you have a Nitro project already set up. Installation [#installation] Install the Integrate SDK in your Nitro project: ```bash bun add integrate-sdk ``` Setup [#setup] Create a server configuration file with your OAuth credentials: ```typescript // server/routes/index.ts import { defineEventHandler } from "h3" import { createMCPServer, githubIntegration, } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); export default defineEventHandler(async (event) => { return serverClient.handler(event.node.req); }); ``` You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash INTEGRATE_API_KEY=your_integrate_api_key GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret FRONTEND_URL=http://localhost:3000 PORT=8080 ``` CORS Setup [#cors-setup] Configure CORS using Nitro middleware: ```typescript // server/middleware/cors.ts import { defineEventHandler, setHeaders } from "h3"; export default defineEventHandler((event) => { // Set CORS headers setHeaders(event, { "Access-Control-Allow-Origin": process.env.FRONTEND_URL || "http://localhost:3000", "Access-Control-Allow-Methods": "GET, POST, OPTIONS", "Access-Control-Allow-Headers": "Content-Type, Authorization", "Access-Control-Allow-Credentials": "true", }); // Handle preflight requests if (event.node.req.method === "OPTIONS") { return new Response(null, { status: 204 }); } }); ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` # Node.js The Integrate SDK provides seamless integration with Node.js through server-side configuration and HTTP route handlers. This guide assumes you have a Node.js project already set up. Installation [#installation] Install the Integrate SDK in your Node.js project: ```bash bun add integrate-sdk ``` Setup [#setup] Create a server configuration file with your OAuth credentials: ```typescript // index.ts import { createServer } from "http"; import { createMCPServer, githubIntegration } from "integrate-sdk/server"; const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); createServer(async (req, res) => { res.setHeader("Access-Control-Allow-Origin", process.env.FRONTEND_URL || "http://localhost:3000"); res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS"); res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization"); res.setHeader("Access-Control-Allow-Credentials", "true"); if (req.method === "OPTIONS") { res.statusCode = 204; res.end(); return; } if (req.url?.startsWith("/api/integrate/")) { await serverClient.handler(req); } else { res.statusCode = 404; res.end("Not Found"); } }).listen(process.env.PORT || 8080, () => { console.log(`Server running on port ${process.env.PORT || 8080}`); }); ``` Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash INTEGRATE_API_KEY=your_integrate_api_key GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret FRONTEND_URL=http://localhost:3000 PORT=8080 ``` You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). CORS Setup [#cors-setup] CORS is configured in the setup above. If you need to customize it, adjust the CORS headers: ```typescript res.setHeader("Access-Control-Allow-Origin", process.env.FRONTEND_URL || "http://localhost:3000"); res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS"); res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization"); res.setHeader("Access-Control-Allow-Credentials", "true"); ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` Full Example [#full-example] ```typescript // index.ts import { createServer } from "http"; import { createMCPServer, githubIntegration } from "integrate-sdk/server"; const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); createServer(async (req, res) => { res.setHeader("Access-Control-Allow-Origin", process.env.FRONTEND_URL || "http://localhost:3000"); res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS"); res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization"); res.setHeader("Access-Control-Allow-Credentials", "true"); if (req.method === "OPTIONS") { res.statusCode = 204; res.end(); return; } if (req.url?.startsWith("/api/integrate/")) { await serverClient.handler(req); } else { res.statusCode = 404; res.end("Not Found"); } }).listen(process.env.PORT || 8080, () => { console.log(`Server running on port ${process.env.PORT || 8080}`); }); ``` # Astro Installation [#installation] Install the Integrate SDK in your Astro project: ```bash bun add integrate-sdk ``` Setup [#setup] 1. Server Configuration [#1-server-configuration] Create a server configuration file with your OAuth credentials: ```typescript // lib/integrate.ts import { createMCPServer, githubIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: import.meta.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ clientId: import.meta.env.GITHUB_CLIENT_ID, clientSecret: import.meta.env.GITHUB_CLIENT_SECRET, scopes: ["repo", "user"], }), ], }); ``` You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). 2. Mount the Handler [#2-mount-the-handler] Create a catch-all API route at `pages/api/integrate/[...all].ts`: ```typescript import { serverClient } from "@/lib/integrate"; import type { APIRoute } from "astro"; export const ALL: APIRoute = async (ctx) => { return serverClient.handler(ctx.request); }; ``` Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` # Next.js The Integrate SDK provides seamless integration with Next.js through server-side configuration and catch-all route handlers. Set up OAuth in just 2 files. Installation [#installation] Install the Integrate SDK in your Next.js project: ```bash bun add integrate-sdk ``` Setup [#setup] Setting up OAuth in Next.js requires only **3 files**: 1. Server Configuration [#1-server-configuration] Create a server configuration file with your OAuth credentials: ```typescript // lib/integrate.ts import { createMCPServer, githubIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); ``` Next.js supports automatically importing the environment variables from the .env file. You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). 2. Mount the Handler [#2-mount-the-handler] Create a single catch-all route that handles all OAuth operations at `app/api/integrate/[...all]/route.ts` ```typescript import { serverClient } from "@/lib/integrate"; import { toNextJsHandler } from "integrate-sdk/server"; export const { POST, GET } = toNextJsHandler(serverClient); ``` Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret ``` Example [#example] Clone the [Next.js example](https://github.com/integratedotdev/examples/tree/main/frameworks/frontend/nextjs-example) for a runnable project with GitHub OAuth and repo listing. Database-backed token storage examples live under [`database/`](https://github.com/integratedotdev/examples/tree/main/database) in the same repo. Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` # Nuxt Installation [#installation] Install the Integrate SDK in your Nuxt project: ```bash bun add integrate-sdk ``` Setup [#setup] 1. Server Configuration [#1-server-configuration] Create a server configuration file with your OAuth credentials: ```typescript // lib/integrate.ts import { createMCPServer, githubIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: import.meta.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); ``` Nuxt supports automatically importing the environment variables from the .env file. You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). 2. Mount the Handler [#2-mount-the-handler] Create a catch-all API route at `server/api/integrate/[...all].ts`: ```typescript import { serverClient } from "~/lib/integrate"; export default defineEventHandler((event) => { return serverClient.handler(toWebRequest(event)); }); ``` Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` # SolidStart Installation [#installation] Install the Integrate SDK in your SolidStart project: ```bash bun add integrate-sdk ``` Setup [#setup] 1. Server Configuration [#1-server-configuration] Create a server configuration file with your OAuth credentials: ```typescript // lib/integrate.ts import { createMCPServer, githubIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); ``` SolidStart supports automatically importing the environment variables from the .env file. You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). 2. Mount the Handler [#2-mount-the-handler] Create a catch-all API route at `routes/api/integrate/[...all].ts`: ```typescript import { toSolidStartHandler } from "integrate-sdk/server"; import { serverClient } from "~/lib/integrate"; const handlers = toSolidStartHandler(serverClient); export const { GET, POST, PATCH, PUT, DELETE } = handlers; ``` Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` # SvelteKit Installation [#installation] Install the Integrate SDK in your SvelteKit project: ```bash bun add integrate-sdk ``` Setup [#setup] 1. Server Configuration [#1-server-configuration] Create a server configuration file with your OAuth credentials: ```typescript // lib/integrate.ts import { createMCPServer, githubIntegration } from "integrate-sdk/server"; import { INTEGRATE_API_KEY, GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET, } from "$env/static/private"; export const { client: serverClient } = createMCPServer({ apiKey: INTEGRATE_API_KEY, integrations: [ githubIntegration({ clientId: GITHUB_CLIENT_ID, clientSecret: GITHUB_CLIENT_SECRET, scopes: ["repo", "user"], }), ], }); ``` You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). 2. Mount the Handler [#2-mount-the-handler] Create a catch-all API route at `routes/api/integrate/[...all]/+server.ts`: ```typescript import { toSvelteKitHandler } from "integrate-sdk/server"; import { serverClient } from "$lib/integrate"; const svelteKitHandler = toSvelteKitHandler(serverClient); export const POST = svelteKitHandler; export const GET = svelteKitHandler; ``` Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` # TanStack Start Installation [#installation] Install the Integrate SDK in your TanStack Start project: ```bash bun add integrate-sdk ``` Setup [#setup] 1. Server Configuration [#1-server-configuration] Create a server configuration file with your OAuth credentials: ```typescript // lib/integrate.ts import { createMCPServer, githubIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); ``` TanStack Start supports automatically importing the environment variables from the .env file. You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). 2. Mount the Handler [#2-mount-the-handler] Create a catch-all route at `routes/api/integrate/$.ts`: ```typescript import { createFileRoute } from "@tanstack/react-router"; import { serverClient } from "@/lib/integrate"; export const Route = createFileRoute("/api/integrate/$")({ server: { handlers: { GET: ({ request }) => { return serverClient.handler(request); }, POST: ({ request }) => { return serverClient.handler(request); }, }, }, }); ``` Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` # Waku Installation [#installation] Install the Integrate SDK in your Waku project: ```bash bun add integrate-sdk ``` Setup [#setup] 1. Server Configuration [#1-server-configuration] Create a server configuration file with your OAuth credentials: ```typescript // lib/integrate.ts import { createMCPServer, githubIntegration } from "integrate-sdk/server"; import { getEnv } from "waku"; export const { client: serverClient } = createMCPServer({ apiKey: getEnv("INTEGRATE_API_KEY")!, integrations: [ githubIntegration({ clientId: getEnv("GITHUB_CLIENT_ID")!, clientSecret: getEnv("GITHUB_CLIENT_SECRET")!, scopes: ["repo", "user"], }), ], }); ``` You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). 2. Mount the Handler [#2-mount-the-handler] Create a catch-all API route at `pages/api/integrate/[...route].ts`: ```typescript import { serverClient } from "@/lib/integrate"; export const GET = serverClient.handler; export const POST = serverClient.handler; ``` Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` # Expo Installation [#installation] Install the Integrate SDK in your Expo project: ```bash bun add integrate-sdk ``` Setup [#setup] 1. Server Configuration [#1-server-configuration] Create a server configuration file with your OAuth credentials: ```typescript // lib/integrate.ts import { createMCPServer, githubIntegration } from "integrate-sdk/server"; export const { client: serverClient } = createMCPServer({ apiKey: process.env.INTEGRATE_API_KEY, integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); ``` Expo supports automatically importing the environment variables from the .env file. You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login). 2. Mount the Handler [#2-mount-the-handler] If using Expo's API Routes feature, create a catch-all route at `app/api/integrate/[...segments]+api.ts`: ```typescript import { serverClient } from "@/lib/integrate"; export const GET = serverClient.handler; export const POST = serverClient.handler; ``` Configuration [#configuration] Add your OAuth credentials to your `.env` file: ```bash GITHUB_CLIENT_ID=your_github_client_id GITHUB_CLIENT_SECRET=your_github_client_secret ``` Server output [#server-output] To make api routes work you need to set `web.output` to `server` in your `app.json` file. ```json { "expo": { "web": { "output": "server" } } } ``` Deep Linking Setup [#deep-linking-setup] Configure deep linking in your `app.json`: ```json { "expo": { "scheme": "myapp", "name": "My App" } } ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "integrate-sdk"; await client.authorize("github"); ``` Handling Deep Links [#handling-deep-links] Set up deep link handling in your app: ```typescript import * as Linking from "expo-linking"; import { useEffect } from "react"; export function OAuthCallback() { useEffect(() => { const handleUrl = ({ url }: { url: string }) => { const { path, queryParams } = Linking.parse(url); if (path === "oauth/callback") { // Handle OAuth callback console.log("OAuth callback:", queryParams); } }; Linking.addEventListener("url", handleUrl); return () => { Linking.removeEventListener("url", handleUrl); }; }, []); return null; } ``` # Lynx The Integrate SDK provides seamless integration with Lynx through client-side configuration. This guide assumes you have a Lynx project and a backend server running with the Integrate SDK configured (see the backend framework guides for setting up the server). Installation [#installation] Install the Integrate SDK in your Lynx project: ```bash bun add integrate-sdk ``` Setup [#setup] Create a client configuration file with your OAuth credentials: ```typescript // src/lib/integrate.ts import { createMCPClient, githubIntegration } from "integrate-sdk"; export const client = createMCPClient({ apiBaseUrl: "http://localhost:8080", integrations: [ githubIntegration({ scopes: ["repo", "user"], }), ], }); ``` Usage Examples [#usage-examples] Client-Side Authorization [#client-side-authorization] The client is automatically configured when making requests to the server. ```typescript import { client } from "./lib/integrate"; await client.authorize("github"); ```