Available Integrations

HIVE Protocol offers a comprehensive integration ecosystem that allows you to connect AI providers, external services, custom tools, and webhooks. This guide provides an overview of all available integrations and how to set them up.

Integration Overview

┌─────────────────────────────────────────────────────────────────┐
│                  HIVE Protocol Integrations                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │                    AI Providers                          │    │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐       │    │
│  │  │ OpenAI  │ │Anthropic│ │ Google  │ │ Ollama  │       │    │
│  │  │ GPT-4o  │ │ Claude  │ │ Gemini  │ │ Local   │       │    │
│  │  └─────────┘ └─────────┘ └─────────┘ └─────────┘       │    │
│  └─────────────────────────────────────────────────────────┘    │
│                                                                  │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │                  External Services                       │    │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐       │    │
│  │  │  Slack  │ │ Discord │ │ GitHub  │ │ Notion  │       │    │
│  │  └─────────┘ └─────────┘ └─────────┘ └─────────┘       │    │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐       │    │
│  │  │ Zapier  │ │ Make    │ │ IFTTT   │ │  n8n    │       │    │
│  │  └─────────┘ └─────────┘ └─────────┘ └─────────┘       │    │
│  └─────────────────────────────────────────────────────────┘    │
│                                                                  │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │                   Custom & Tools                         │    │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐       │    │
│  │  │Webhooks │ │ Custom  │ │  REST   │ │Database │       │    │
│  │  │         │ │  Tools  │ │  APIs   │ │ Connect │       │    │
│  │  └─────────┘ └─────────┘ └─────────┘ └─────────┘       │    │
│  └─────────────────────────────────────────────────────────┘    │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

AI Provider Integrations

Connect to the world's leading AI model providers to power your agents.

OpenAI

Industry-leading GPT models for general-purpose AI tasks.

Integration	Status	Models Available
OpenAI API	Available	GPT-4o, GPT-4o Mini, GPT-4 Turbo, GPT-3.5 Turbo

Features:

Vision capabilities for image analysis
Function calling for tool use
JSON mode for structured output
Streaming responses

Quick Setup:

1. Get API key from platform.openai.com
2. Go to Settings > Integrations > OpenAI
3. Enter API key and save
4. Select as default or per-agent

Full OpenAI Setup Guide

Anthropic

Claude models known for nuanced reasoning and safety.

Integration	Status	Models Available
Anthropic API	Available	Claude Sonnet 4, Claude 3.5 Sonnet, Claude 3 Opus, Claude 3 Haiku

Features:

200K token context window
Vision capabilities
Strong instruction following
Excellent for complex reasoning

Quick Setup:

1. Get API key from console.anthropic.com
2. Go to Settings > Integrations > Anthropic
3. Enter API key and save
4. Assign to agents as needed

Full Anthropic Setup Guide

Google AI

Gemini models with massive context windows.

Integration	Status	Models Available
Google AI API	Available	Gemini 1.5 Pro, Gemini 1.5 Flash

Features:

1 million token context window
Multimodal (text, image, video, audio)
Extremely cost-effective
Fast response times

Quick Setup:

1. Get API key from aistudio.google.com
2. Go to Settings > Integrations > Google AI
3. Enter API key and save
4. Enable desired models

Full Google AI Setup Guide

Local Models (Ollama)

Run models locally for privacy and cost savings.

Integration	Status	Models Available
Ollama	Available	Llama 3.1, Mistral, Code Llama, Qwen, Phi-3

Features:

Complete data privacy
No per-token costs
Offline operation
Self-hosted control

Full Local Models Guide

External Service Integrations

Connect HIVE to your existing tools and workflows.

Communication Platforms

Slack

Send notifications and interact with HIVE from Slack.

Integration Type: Webhook + Bot
Setup Time: ~5 minutes
Use Cases:
  - Receive swarm notifications
  - Send messages from Slack
  - Alert on agent errors

Setup Steps:

Create Slack App at api.slack.com
Enable Incoming Webhooks
Add webhook URL to HIVE Settings
Select events to notify

Example Webhook Payload to Slack:

const sendSlackNotification = async (message) => {
  await fetch(SLACK_WEBHOOK_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      text: message.content,
      blocks: [
        {
          type: 'section',
          text: {
            type: 'mrkdwn',
            text: `*New message in ${message.swarm_name}*\n${message.content}`
          }
        }
      ]
    })
  });
};

Discord

Integrate HIVE with Discord servers.

Integration Type: Webhook
Setup Time: ~3 minutes
Use Cases:
  - Team notifications
  - Bot interactions
  - Activity feeds

Setup Steps:

Create Discord webhook in channel settings
Copy webhook URL
Add to HIVE webhook configuration
Map events to Discord channels

Productivity Tools

Notion

Sync HIVE data with Notion databases.

Integration Type: API
Setup Time: ~10 minutes
Use Cases:
  - Log agent activities
  - Create documentation
  - Track swarm outputs

Example: Creating Notion Page from Agent Output:

const notion = new Client({ auth: NOTION_API_KEY });

async function saveToNotion(agentOutput) {
  await notion.pages.create({
    parent: { database_id: DATABASE_ID },
    properties: {
      'Title': {
        title: [{ text: { content: agentOutput.title } }]
      },
      'Content': {
        rich_text: [{ text: { content: agentOutput.content } }]
      },
      'Agent': {
        select: { name: agentOutput.agent_name }
      },
      'Created': {
        date: { start: new Date().toISOString() }
      }
    }
  });
}

GitHub

Connect HIVE to GitHub for code-related tasks.

Integration Type: OAuth + Webhooks
Setup Time: ~10 minutes
Use Cases:
  - Trigger agents on PR events
  - Create issues from agent outputs
  - Code review automation

Automation Platforms

Connect HIVE to no-code automation platforms.

Zapier

Trigger Events:
  - New message created
  - Swarm completed
  - Agent error occurred

Actions:
  - Send message to swarm
  - Create new agent
  - Trigger agent response

Make (Integromat)

Modules Available:
  - Watch for events
  - Send messages
  - Manage swarms
  - Execute tools

n8n (Self-hosted)

Nodes Available:
  - HIVE Trigger
  - HIVE Action
  - Custom webhook handler

Integration Patterns

Pattern 1: Event-Driven Workflow

┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
│  HIVE    │───▶│ Webhook  │───▶│  Zapier  │───▶│  Action  │
│  Event   │    │ Trigger  │    │ Workflow │    │(Slack,etc)│
└──────────┘    └──────────┘    └──────────┘    └──────────┘

Example: Auto-notify team on completion

// HIVE sends webhook when swarm completes
{
  "type": "swarm.completed",
  "data": {
    "swarm_id": "swm_123",
    "name": "Research Task",
    "result": "Analysis complete"
  }
}

// Zapier catches and sends to Slack
// -> "#team-updates: Research Task completed!"

Pattern 2: Bidirectional Sync

┌──────────┐    ┌──────────┐    ┌──────────┐
│  HIVE    │◀──▶│   API    │◀──▶│ External │
│ Protocol │    │  Bridge  │    │  System  │
└──────────┘    └──────────┘    └──────────┘

Example: Sync with project management

// Sync HIVE tasks with external project tracker
async function syncBidirectional() {
  // Get HIVE updates
  const hiveUpdates = await hive.getRecentActivity();

  // Push to external system
  for (const update of hiveUpdates) {
    await external.createOrUpdate(update);
  }

  // Get external updates
  const externalUpdates = await external.getChanges();

  // Push to HIVE
  for (const update of externalUpdates) {
    await hive.sendMessage(update.swarmId, update.content);
  }
}

Pattern 3: Tool Chain Integration

┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
│  Agent   │───▶│ Custom   │───▶│ External │───▶│ Process  │
│ Request  │    │  Tool    │    │   API    │    │  Result  │
└──────────┘    └──────────┘    └──────────┘    └──────────┘

Example: Agent uses external API via custom tool

// Custom tool definition
const weatherTool = {
  name: 'get_weather',
  description: 'Get current weather for a location',
  parameters: {
    type: 'object',
    properties: {
      location: { type: 'string', description: 'City name' }
    },
    required: ['location']
  },
  execute: async ({ location }) => {
    const response = await fetch(
      `https://api.weather.com/v1/current?q=${location}&key=${API_KEY}`
    );
    return response.json();
  }
};

Setting Up Integrations

Quick Start Checklist

[ ] 1. Identify integration needs
    - Which AI providers do you need?
    - What external services to connect?
    - What events should trigger actions?

[ ] 2. Gather credentials
    - API keys for providers
    - Webhook URLs for services
    - OAuth tokens for platforms

[ ] 3. Configure in HIVE
    - Settings > Integrations
    - Add credentials securely
    - Test connections

[ ] 4. Set up event handling
    - Configure webhooks
    - Map events to actions
    - Test end-to-end flow

[ ] 5. Monitor and iterate
    - Check delivery logs
    - Monitor error rates
    - Optimize as needed

Managing Integration Credentials

┌─────────────────────────────────────────────────────────────────┐
│  Settings > Integrations                                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  AI Providers                                                    │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ OpenAI        [Connected]    API Key: sk-...xxxx  [Edit]│    │
│  │ Anthropic     [Connected]    API Key: sk-ant...   [Edit]│    │
│  │ Google AI     [Not Setup]                        [Setup]│    │
│  │ Ollama        [Connected]    localhost:11434     [Edit] │    │
│  └─────────────────────────────────────────────────────────┘    │
│                                                                  │
│  Webhooks                                                        │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ Slack Notifier    [Active]   12 events    [Manage]      │    │
│  │ Discord Bot       [Active]    5 events    [Manage]      │    │
│  │ + Add Webhook                                            │    │
│  └─────────────────────────────────────────────────────────┘    │
│                                                                  │
│  Custom Tools                                                    │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │ Weather API       [Active]   Used by 3 agents   [Edit]  │    │
│  │ Database Query    [Active]   Used by 5 agents   [Edit]  │    │
│  │ + Create Tool                                            │    │
│  └─────────────────────────────────────────────────────────┘    │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Security Best Practices

Credential Management

DO:
  - Store API keys in HIVE's secure storage
  - Use environment-specific credentials
  - Rotate keys regularly
  - Set appropriate scopes/permissions
  - Monitor for unusual activity

DON'T:
  - Share credentials across environments
  - Log or expose keys in code
  - Use overly permissive scopes
  - Ignore security alerts

Webhook Security

Always verify webhook signatures:
  - HIVE signs all outgoing webhooks
  - Verify using the shared secret
  - Reject unverified requests
  - Use HTTPS endpoints only

Rate Limiting

Respect provider limits:
  - OpenAI: Varies by tier (500-10,000 RPM)
  - Anthropic: 60-4,000 RPM
  - Google: 1,500 RPM

HIVE implements automatic:
  - Request queuing
  - Exponential backoff
  - Retry with jitter

Troubleshooting

Common Issues

Issue	Cause	Solution
Connection failed	Invalid credentials	Re-check API key
Rate limited	Too many requests	Enable request queuing
Webhook not firing	Wrong URL or events	Verify configuration
Tool timeout	Slow external API	Increase timeout setting
Auth expired	Token expiration	Refresh OAuth token

Debugging Steps

1. Check connection status in Settings > Integrations

2. View webhook delivery logs:
   - Go to Settings > Webhooks
   - Click on the webhook
   - View Recent Deliveries

3. Test integration manually:
   - Use the Test button
   - Check response status
   - Review payload format

4. Check error logs:
   - Settings > Activity Log
   - Filter by integration type
   - Look for error patterns

[OpenAI Integration](/docs/integrations/openai): Detailed OpenAI setup
[Anthropic Integration](/docs/integrations/anthropic): Detailed Anthropic setup
[Google AI Integration](/docs/integrations/google): Detailed Google AI setup
[Webhooks](/docs/integrations/webhooks): Full webhook reference
[Custom Tools](/docs/integrations/custom-tools): Build your own tools

Available Integrations

Available Integrations

Integration Overview

AI Provider Integrations

OpenAI

Anthropic

Google AI

Local Models (Ollama)

External Service Integrations

Communication Platforms

Slack

Discord

Productivity Tools

Notion

GitHub

Automation Platforms

Zapier

Make (Integromat)

n8n (Self-hosted)

Integration Patterns

Pattern 1: Event-Driven Workflow

Pattern 2: Bidirectional Sync

Pattern 3: Tool Chain Integration

Setting Up Integrations

Quick Start Checklist

Managing Integration Credentials

Security Best Practices

Credential Management

Webhook Security

Rate Limiting

Troubleshooting

Common Issues

Debugging Steps

Related Documentation

Cookie Preferences