Integrations Overview

Integrations connect your agents to the tools and services your organization already uses. From Google Workspace to Salesforce, Deeployd provides pre-built connectors that work out of the box.

How Integrations Work

Agent ──▶ Integration ──OAuth──▶ External Service
                         │
                    MCP Protocol

1. User authorizes connection via OAuth
2. Deeployd securely stores tokens
3. Agent uses MCP tools to interact with service
4. Integration handles authentication and API calls

Integration Catalog

Browse available integrations by category:

Productivity

Integration	Tools	Status
Google Workspace	Gmail, Drive, Calendar, Docs, Sheets	Available
Microsoft 365	Outlook, OneDrive, Teams, Excel, Word	Available
Notion	Pages, databases, search	Available
Slack	Messages, channels, threads	Available

Admin & IT

Integration	Tools	Status
Google Admin	User provisioning, groups, licenses	Available
Microsoft Admin	User management, groups, licenses	Available
Okta	User management, SSO	Available
Jira	Issues, projects, workflows	Available
ServiceNow	Incidents, requests, CMDB	Available

CRM & Sales

Integration	Tools	Status
Salesforce	Contacts, opportunities, cases	Available
HubSpot	Contacts, deals, tickets	Available
Pipedrive	Deals, contacts, activities	Available

Development

Integration	Tools	Status
GitHub	Repos, issues, PRs, actions	Available
GitLab	Projects, merge requests	Available
Linear	Issues, projects, cycles	Available

Data & Analytics

Integration	Tools	Status
Snowflake	Query, tables	Available
BigQuery	Query, datasets	Available
PostgreSQL	Query, tables	Available
MongoDB	Documents, collections	Available

Communication

Integration	Tools	Status
Slack	Messages, channels	Available
Microsoft Teams	Messages, channels	Available
Discord	Messages, channels	Available
Twilio	SMS, voice	Available

Storage

Integration	Tools	Status
Google Drive	Files, folders, sharing	Available
OneDrive	Files, folders, sharing	Available
Dropbox	Files, folders, sharing	Available
Box	Files, folders, sharing	Available

Payments

Integration	Tools	Status
Stripe	Customers, payments, subscriptions	Available
PayPal	Payments, transactions	Available

Connecting an Integration

Via Dashboard

1. Go to Integrations in the sidebar
2. Browse or search for the integration
3. Click Connect
4. Complete OAuth authorization
5. Configure settings (optional)
6. Assign to agents

Via API

// List available integrations
const catalog = await client.integrations.getCatalog({
  category: 'productivity',
  status: 'available'
});

// Initiate OAuth connection
const connection = await client.integrations.connect({
  integrationId: 'google-workspace',
  redirectUrl: 'https://your-app.com/oauth/callback',
  scopes: ['gmail.modify', 'drive', 'calendar']
});

// Redirect user to OAuth URL
window.location.href = connection.authUrl;

OAuth Callback

// Handle OAuth callback
app.get('/oauth/callback', async (req, res) => {
  const { code, state } = req.query;

  const connection = await client.integrations.completeConnection({
    code,
    state
  });

  console.log('Connected:', connection.integrationName);
  res.redirect('/integrations');
});

Managing Connections

List Connections

const connections = await client.integrations.listConnections();

for (const conn of connections.data) {
  console.log({
    integration: conn.integrationName,
    status: conn.status,
    connectedAt: conn.createdAt,
    expiresAt: conn.expiresAt
  });
}

Test Connection

const result = await client.integrations.testConnection('connection-123');

if (result.success) {
  console.log('Connection is healthy');
} else {
  console.log('Connection issue:', result.error);
}

Refresh Token

await client.integrations.refreshConnection('connection-123');

Revoke Connection

await client.integrations.revokeConnection('connection-123');

Assigning to Agents

Via Dashboard

1. Go to Agents → Select agent → Integrations
2. Toggle integrations on/off
3. Select specific tools to enable
4. Save changes

Via API

await client.agents.update('agent-123', {
  integrations: [
    {
      connectionId: 'connection-456',
      tools: ['gmail_search', 'gmail_send', 'calendar_create']
    }
  ]
});

Integration Tools

Each integration provides specific tools:

Tool Discovery

// List tools for an integration
const tools = await client.integrations.listTools('google-workspace');

for (const tool of tools) {
  console.log({
    name: tool.name,
    description: tool.description,
    inputSchema: tool.inputSchema
  });
}

Tool Categories

Category	Description
Read	Fetch data (search, list, get)
Write	Create/update data
Delete	Remove data
Admin	User management, permissions

Security Considerations

OAuth Scopes

Request only the scopes you need:

// ✅ Good - minimal scopes
scopes: ['gmail.readonly', 'calendar.readonly']

// ❌ Bad - overly broad
scopes: ['https://www.googleapis.com/auth/gmail']

Token Storage

• Tokens are encrypted at rest (AES-256)
• Access tokens auto-refresh before expiry
• Refresh tokens are never exposed to agents

Audit Logging

All integration actions are logged:

const logs = await client.audit.list({
  resourceType: 'integration',
  action: 'integration.tool_executed'
});

Rate Limits

Deeployd respects external service rate limits:

Service	Limit	Handling
Google APIs	Varies by API	Automatic retry with backoff
Microsoft Graph	10,000/10min	Queued requests
Slack	50/min	Rate limit headers

Troubleshooting

Connection Expired

// Check connection status
const conn = await client.integrations.getConnection('connection-123');

if (conn.status === 'expired') {
  // Refresh or re-authenticate
  await client.integrations.refreshConnection('connection-123');
}

Permission Denied

1. Check OAuth scopes granted
2. Verify user has permission in external service
3. Re-authorize with additional scopes if needed

Tool Execution Failed

try {
  await client.mcp.callTool({ name: 'gmail_send', arguments: {...} });
} catch (error) {
  if (error.code === 'INTEGRATION_ERROR') {
    console.log('External service error:', error.details);
  }
}

Custom Integrations

Build your own integrations:

// Create custom tool
await client.tools.create({
  name: 'custom_crm_lookup',
  description: 'Look up customer in custom CRM',
  executionType: 'http',
  executionConfig: {
    url: 'https://api.custom-crm.com/customers/${customerId}',
    method: 'GET',
    headers: {
      'Authorization': 'Bearer ${secrets.CRM_TOKEN}'
    }
  },
  secretsRequired: ['CRM_TOKEN']
});

See Custom Tools for details.

---

Next: Explore Google Workspace integration.