kubiya_external_knowledge

The kubiya_external_knowledge resource manages external knowledge integrations in the Kubiya platform. This resource allows you to connect external systems to the Kubiya RAG (Retrieval-Augmented Generation) system through a vendor-agnostic interface, enabling agents to access and learn from external data sources like Slack conversations, documentation systems, and other knowledge repositories.

External knowledge integrations supercharge your agents by providing access to historical conversations, institutional knowledge, and contextual information that makes responses more accurate and relevant.

Prerequisites

Before using this resource, ensure you have:

A Kubiya account with API access
An API key (generated from Kubiya dashboard under Admin → Kubiya API Keys)
Access to the external system you want to integrate (e.g., Slack workspace)
Appropriate permissions in the external system

Quick Start

resource "kubiya_external_knowledge" "slack_general" {
  vendor = "slack"
  config = {
    channel_ids = ["C1234567890"]  # General channel ID
  }
}

resource "kubiya_agent" "slack_aware_agent" {
  name         = "slack-aware-assistant"
  runner       = "kubiya-hosted"
  description  = "Agent with access to Slack knowledge"
  instructions = "You have access to historical Slack conversations. Reference relevant discussions when answering questions."
}

Configuration Examples

Set up knowledge integration for incident response and post-mortem analysis:

resource "kubiya_external_knowledge" "incident_channels" {
  vendor = "slack"
  config = {
    channel_ids = [
      "C9999999999",  # #incidents
      "CAAAAAAAAAA",  # #incident-postmortems
      "CBBBBBBBBBB"   # #incident-logs
    ]
  }
}

resource "kubiya_agent" "incident_historian" {
  name         = "incident-historian"
  runner       = "kubiya-hosted"
  description  = "Incident response knowledge agent"
  instructions = <<-EOT
    You have access to incident-related Slack channels.
    Use this knowledge to:
    - Provide context on past incidents
    - Identify patterns in recurring issues
    - Reference previous solutions
    - Help with post-mortem analysis
    - Suggest preventive measures based on history
  EOT
  
  integrations = ["slack", "pagerduty"]
  groups       = ["DevOps", "SRE", "Engineering"]
}

Advanced Configurations

Compliance and Security Knowledge

Set up secure knowledge integration for compliance and security teams:

resource "kubiya_external_knowledge" "compliance_knowledge" {
  vendor = "slack"
  config = {
    channel_ids = [
      "CMMMMMMMMMMM",  # #compliance
      "CNNNNNNNNNNN",  # #security-alerts
      "COOOOOOOOOO"    # #audit-logs
    ]
  }
}

resource "kubiya_agent" "compliance_agent" {
  name         = "compliance-knowledge-agent"
  runner       = "kubiya-hosted"
  description  = "Compliance and security knowledge agent"
  instructions = <<-EOT
    You have access to compliance and security Slack channels.
    IMPORTANT: This information is sensitive.
    
    Use this knowledge to:
    - Answer compliance-related questions
    - Provide context on security decisions
    - Reference audit discussions
    - Help with compliance reporting
    
    Always maintain confidentiality and follow security protocols.
    Only share information with authorized personnel.
  EOT
  
  groups = ["Compliance", "Security", "Legal"]
}

# Security incident response agent
resource "kubiya_agent" "security_responder" {
  name         = "security-incident-responder"
  runner       = "kubiya-hosted"
  description  = "Security incident response agent with historical context"
  instructions = <<-EOT
    You have access to security-related channels and specialize in incident response.
    
    Use knowledge to:
    - Analyze patterns in security incidents
    - Reference previous incident responses
    - Provide context on threat landscape
    - Assist with forensic analysis
    
    Always follow security protocols and escalate appropriately.
  EOT
  
  integrations = ["slack", "crowdstrike", "splunk"]
  groups       = ["Security", "SOC"]
}

Multi-Vendor Knowledge Strategy

Plan for future multi-vendor integrations:

# Current Slack integration
resource "kubiya_external_knowledge" "current_slack" {
  vendor = "slack"
  config = {
    channel_ids = [
      "C1234567890",
      "C0987654321",
      "C1111111111"
    ]
  }
}

# Placeholder for future integrations
# resource "kubiya_external_knowledge" "confluence_docs" {
#   vendor = "confluence"
#   config = {
#     space_keys = ["ENG", "PROD", "OPS"]
#     page_labels = ["documentation", "runbook", "architecture"]
#   }
# }

# Multi-source knowledge agent
resource "kubiya_agent" "comprehensive_assistant" {
  name         = "comprehensive-knowledge-assistant"
  runner       = "kubiya-hosted"
  description  = "Agent with access to multiple knowledge sources"
  instructions = <<-EOT
    You have access to multiple knowledge sources:
    - Historical Slack conversations
    - [Future: Confluence documentation]
    - [Future: Notion pages]
    - [Future: GitHub discussions]
    
    Use all available knowledge to provide comprehensive, well-informed responses.
    Always cite your sources when referencing specific information.
  EOT
  
  groups = ["Engineering", "Product", "Support"]
}

Knowledge Governance and Monitoring

Implement governance and monitoring for knowledge integrations:

locals {
  knowledge_integrations = {
    engineering = {
      channels = ["C111", "C222", "C333"]
      groups   = ["Engineering"]
      sensitive = false
    }
    security = {
      channels = ["C444", "C555"]
      groups   = ["Security", "Compliance"]
      sensitive = true
    }
    customer_success = {
      channels = ["C666", "C777", "C888"]
      groups   = ["Support", "Customer Success"]
      sensitive = false
    }
  }
}

resource "kubiya_external_knowledge" "managed_integrations" {
  for_each = local.knowledge_integrations
  
  vendor = "slack"
  config = {
    channel_ids = each.value.channels
  }
}

resource "kubiya_agent" "knowledge_governance" {
  name         = "knowledge-governance-agent"
  runner       = "kubiya-hosted"
  description  = "Monitor and govern knowledge integrations"
  instructions = <<-EOT
    You monitor knowledge integration usage and governance:
    - Track which knowledge sources are being accessed
    - Monitor for potential privacy issues
    - Generate usage reports
    - Alert on unusual access patterns
    
    Maintain strict confidentiality and follow data governance policies.
  EOT
  
  groups = ["Data Governance", "Compliance"]
}

# Monitoring agents for each integration
resource "kubiya_agent" "integration_monitors" {
  for_each = local.knowledge_integrations
  
  name         = "${each.key}-knowledge-monitor"
  runner       = "kubiya-hosted"
  description  = "Monitor ${each.key} knowledge integration"
  instructions = <<-EOT
    You monitor the ${each.key} knowledge integration.
    ${each.value.sensitive ? "This integration contains sensitive information." : ""}
    
    Responsibilities:
    - Track usage patterns
    - Monitor for compliance issues
    - Generate usage reports
    ${each.value.sensitive ? "- Ensure sensitive information is properly protected" : ""}
  EOT
  
  groups = concat(each.value.groups, ["Data Governance"])
}

Arguments Reference

Required Arguments

vendor

string

required

The vendor/provider for the knowledge integration. Currently supported values:

slack - Slack channel integrations

config

object

required

Dynamic configuration map with vendor-specific keys and values. The structure depends on the vendor being used.

Vendor-Specific Configuration

Slack Configuration

For vendor = "slack", the config object requires:

config.channel_ids

array

required

List of Slack channel IDs to integrate. Each ID should be in the format “C1234567890”. You can find channel IDs in Slack by:

Right-clicking on a channel
Selecting “Copy link”
The ID is the part after “/channels/” in the URL

Example Slack configuration:

config = {
  channel_ids = ["C1234567890", "C0987654321"]
}

Attributes Reference

In addition to all arguments above, the following attributes are exported:

string

The unique identifier of the external knowledge integration.

org

string

The organization associated with the integration.

start_date

string

The start date from which knowledge is indexed.

integration_type

string

The type of integration (matches the vendor).

created_at

string

The timestamp when the integration was created.

updated_at

string

The timestamp when the integration was last updated.

How to Find Slack Channel IDs

1. Open Slack in your web browser
2. Navigate to the desired channel
3. Look at the URL: https://app.slack.com/client/T123/C1234567890
4. The channel ID is the part after the last slash (C1234567890)

Import

External knowledge integrations can be imported using their ID:

terraform import kubiya_external_knowledge.example <external-knowledge-id>

Best Practices

Channel Selection

Choose channels with valuable, relevant knowledge content
Avoid extremely high-volume channels that may create noise
Select channels with good signal-to-noise ratio
Consider the longevity and relevance of channel content

Privacy & Compliance

Ensure compliance with data privacy policies and regulations
Review channel content for sensitive information before integration
Implement appropriate access controls for sensitive knowledge
Regular audit of integrated channels and their content

Access Control

Limit agent access to sensitive knowledge integrations
Use groups to control which users can access specific knowledge
Regularly review and update access permissions
Implement least-privilege access principles

Performance & Maintenance

Monitor knowledge usage and relevance over time
Regular cleanup of obsolete or irrelevant integrations
Update channel lists as organizational structure changes
Test knowledge retrieval effectiveness in non-production environments

Knowledge Integration Patterns

# Separate integrations per team
resource "kubiya_external_knowledge" "frontend_team" {
  vendor = "slack"
  config = {
    channel_ids = ["C_FRONTEND_1", "C_FRONTEND_2"]
  }
}

resource "kubiya_external_knowledge" "backend_team" {
  vendor = "slack"
  config = {
    channel_ids = ["C_BACKEND_1", "C_BACKEND_2"]
  }
}

Compatibility

Requirements:

Kubiya Terraform Provider version >= 1.0.0
Terraform >= 1.0
Slack integration requires OAuth setup in Kubiya dashboard
Channel IDs must be valid and accessible

Processing Time:

Knowledge indexing may take time after initial creation
Historical data retrieval limits may apply based on platform tier
Large channels may require additional processing time
Changes to channel content are indexed incrementally

Important Considerations:

Ensure proper permissions in Slack workspace
Be aware of data privacy and compliance requirements
Monitor for sensitive information in indexed content
Consider impact on system performance with large integrations

Troubleshooting

Integration Setup Issues

Knowledge Indexing Problems

Agent Access Issues

Getting Started

Resources

kubiya_external_knowledge

Prerequisites

Quick Start

Configuration Examples

Advanced Configurations

Arguments Reference

Required Arguments

Vendor-Specific Configuration

Slack Configuration

Attributes Reference

How to Find Slack Channel IDs

Import

Best Practices

Channel Selection

Privacy & Compliance

Access Control

Performance & Maintenance

Knowledge Integration Patterns

Compatibility

Troubleshooting

Getting Started

Resources

​Prerequisites

​Quick Start

​Configuration Examples

​Advanced Configurations

​Arguments Reference

​Required Arguments

​Vendor-Specific Configuration

​Slack Configuration

​Attributes Reference

​How to Find Slack Channel IDs

​Import

​Best Practices

Channel Selection

Privacy & Compliance

Access Control

Performance & Maintenance

​Knowledge Integration Patterns

​Compatibility

​Troubleshooting

Prerequisites

Quick Start

Configuration Examples

Advanced Configurations

Arguments Reference

Required Arguments

Vendor-Specific Configuration

Slack Configuration

Attributes Reference

How to Find Slack Channel IDs

Import

Best Practices

Knowledge Integration Patterns

Compatibility

Troubleshooting