Enterprise docs (#7714)

* enterprise docs

* tested for accuracy

* Reorganize Enterprise docs structure

- Consolidate member management under team-management/
- Unify all configuration under configuration/ with two clear paths:
  - remote-configuration/ for simple cloud-based setup
  - infrastructure-configuration/ for advanced enterprise features
- Create comprehensive overview pages explaining the differences
- Update all internal links to reflect new paths
- Preserve all existing content while eliminating redundancy
- Maintain clear separation between admin and member documentation

* removed trailing backslash

* fix docs.json

* enterprise docs reformat

* monday update

* tidied up managing members section

* fixed deployment guide

* simplify rules

* workflow cleanup

* rules tweak

* Update docs/enterprise-solutions/configuration/overview.mdx

Co-authored-by: ellipsis-dev[bot] <65095814+ellipsis-dev[bot]@users.noreply.github.com>

* fix other features

* fixed provider docs

* fixed monitoring

* fix providers

* updated cta and rbac

* fix enterprise overview

* enterprise-docs

* hid self-hosted section for now

* addressed format fixed

* docs: restructure monitoring navigation and move telemetry

- Remove unnecessary OpenTelemetry dropdown wrapper in Enterprise navigation
- Move Cline Telemetry from control-other-cline-features to monitoring section
- Update all internal documentation links to new telemetry path
- Simplify Control Other Cline Features section to focus on Yolo Mode only
- Group related monitoring features (overview, telemetry, opentelemetry) together

This creates a more cohesive navigation structure where telemetry-related
features are adjacent and eliminates unnecessary nested dropdowns.

* docs: rename Basic Telemetry to Cline Telemetry and add link

- Rename all instances of 'Basic Telemetry' to 'Cline Telemetry' for consistency
- Add href link to Cline Telemetry card in Monitoring Options section
- Update section headings and subheadings to use 'Cline Telemetry'
- Ensures consistent naming across monitoring documentation

* docs: restructure Enterprise YOLO Mode to focus on administrator controls

- Change title from 'Yolo Mode' to 'YOLO Mode' for consistency
- Add reference link to /features/yolo-mode for general documentation
- Remove duplicate content about basic YOLO Mode functionality
- Focus exclusively on Enterprise administrator configuration and controls
- Add comprehensive policy recommendations by organization size
- Include security implications, monitoring requirements, and compliance considerations
- Provide detailed technical implementation guidance
- Update overview.mdx card description to reflect enterprise focus

* docs: hide self-hosted/infrastructure configuration references

- Remove choosing-your-deployment from Enterprise navigation
- Remove self-hosted references from enterprise-solutions/overview.mdx
- Remove self-hosted comparison and warning from remote-configuration/overview.mdx
- Remove Info boxes linking to infrastructure config from provider pages (AWS, Google, LiteLLM)
- Remove Self-Hosted OpenTelemetry Collector section from opentelemetry.mdx
- Remove self-hosted deployment section from control-other-cline-features/overview.mdx

All self-hosted/infrastructure configuration documentation remains intact but is no longer
navigable or linked from SaaS provider configuration pages. This allows easy restoration
when features become available.

* clarified domain and seat info

* fixed getOpenTabs function

* Update getOpenTabs.ts

* Update package.json

* Revert package-lock files to main

---------

Co-authored-by: ellipsis-dev[bot] <65095814+ellipsis-dev[bot]@users.noreply.github.com>
Co-authored-by: Juan Pablo Flores <juan@cline.bot>
This commit is contained in:
Tony Loehr
2025-12-10 11:05:14 -08:00
committed by GitHub
co-authored by ellipsis-dev[bot] Juan Pablo Flores
parent 91940fbb4a
commit 1be314dfed
33 changed files with 5826 additions and 252 deletions
+43 -6
View File
@@ -278,18 +278,47 @@
"pages": [
"enterprise-solutions/overview",
"enterprise-solutions/onboarding",
"enterprise-solutions/members/roles-and-permissions",
"enterprise-solutions/team-management/managing-members",
{
"group": "Provider Remote Configuration",
"group": "SaaS Provider Configuration",
"pages": [
"enterprise-solutions/configuration/remote-configuration/overview",
{
"group": "AWS Bedrock",
"pages": [
"enterprise-solutions/provider-remote-config/aws-bedrock/admin-configuration",
"enterprise-solutions/provider-remote-config/aws-bedrock/member-configuration"
"enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration",
"enterprise-solutions/configuration/remote-configuration/aws-bedrock/member-configuration"
]
},
{
"group": "LiteLLM",
"pages": [
"enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration",
"enterprise-solutions/configuration/remote-configuration/litellm/member-configuration"
]
},
{
"group": "Google Vertex AI",
"pages": [
"enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration",
"enterprise-solutions/configuration/remote-configuration/google-vertex/member-configuration"
]
}
]
},
{
"group": "Control Other Cline Features",
"pages": [
"enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/yolo-mode"
]
},
{
"group": "Monitoring",
"pages": [
"enterprise-solutions/monitoring/overview",
"enterprise-solutions/monitoring/telemetry",
"enterprise-solutions/monitoring/opentelemetry"
]
}
]
}
@@ -367,11 +396,11 @@
},
{
"source": "/enterprise-solutions/configure-AWS-Bedrock-Admin",
"destination": "/enterprise-solutions/provider-remote-config/aws-bedrock/admin-configuration"
"destination": "/enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration"
},
{
"source": "/enterprise-solutions/configure-AWS-Bedrock-Member",
"destination": "/enterprise-solutions/provider-remote-config/aws-bedrock/member-configuration"
"destination": "/enterprise-solutions/configuration/remote-configuration/aws-bedrock/member-configuration"
},
{
"source": "/enterprise-solutions/configure-workOS-authkit",
@@ -380,6 +409,14 @@
{
"source": "/enterprise-solutions/Onboarding your Organization",
"destination": "/enterprise-solutions/onboarding"
},
{
"source": "/enterprise-solutions/team-management/overview",
"destination": "/enterprise-solutions/team-management/managing-members"
},
{
"source": "/enterprise-solutions/team-management/roles-and-permissions",
"destination": "/enterprise-solutions/team-management/managing-members"
}
],
"search": {
@@ -0,0 +1,105 @@
---
title: "Choosing Your Configuration Path"
sidebarTitle: "Deployment Guide"
description: "Decide between SaaS and Self-Hosted configuration for your Cline Enterprise deployment"
---
Choose the right configuration approach for your organization. Most teams start with SaaS for quick deployment, while enterprises with complex requirements opt for self-hosted infrastructure.
## Configuration Paths
<CardGroup cols={2}>
<Card title="SaaS Provider Configuration" icon="cloud" href="/enterprise-solutions/configuration/remote-configuration/overview">
### Quick Setup via Web Console
✅ No infrastructure required
✅ 5-10 minute configuration
✅ Web-based admin console
✅ Automatic updates
✅ Simplified credential management
**Best for:**
- Small to medium teams (5-50 developers)
- Quick deployment needs
- Limited DevOps resources
- Standard security requirements
- Single region deployments
</Card>
<Card title="Self-Hosted Configuration" icon="server" href="/enterprise-solutions/configuration/infrastructure-configuration/overview">
### Full Infrastructure Control
✅ Your own AWS/GCP/K8s
✅ VPC endpoints & private connectivity
✅ Multi-account setups
✅ Advanced compliance & audit
✅ GitOps workflows
**Best for:**
- Large enterprises (50+ developers)
- Complex security requirements
- Existing cloud infrastructure
- Multi-region deployments
- Custom compliance needs
</Card>
</CardGroup>
## Detailed Comparison
### Feature Comparison
| Feature | SaaS | Self-Hosted |
|---------|------|-------------|
| **Configuration** | Web UI | YAML + Helm/Kubernetes |
| **Infrastructure** | None required | Full AWS/GCP/K8s |
| **VPC Endpoints** | Basic | Full private connectivity |
| **Multi-Account** | ❌ | ✅ |
| **IAM** | Standard RBAC roles | Standard RBAC roles |
| **Compliance** | Standard | Custom frameworks |
| **GitOps** | ❌ | ✅ |
| **Maintenance** | Managed by Cline | Self-managed |
| **Updates** | Automatic (extension) | Automatic (extension) + Infrastructure control |
### Security & Compliance
| Capability | SaaS | Self-Hosted |
|------------|------|-------------|
| **Network Encryption** | HTTPS/TLS | HTTPS/TLS |
| **Network** | Public internet | Private VPC endpoints |
| **Access Control** | Standard RBAC | Standard RBAC |
| **Audit Logs** | OpenTelemetry traces | OpenTelemetry traces + Infrastructure logs |
| **Data Residency** | Cline-managed deployment | Customer-controlled deployment |
### Cost Structure
| Cost Category | SaaS | Self-Hosted |
|---------------|------|-------------|
| **Cline Subscription** | Fixed enterprise fee | Fixed enterprise fee |
| **Inference Provider Costs** | Usage-based | Usage-based |
| **Infrastructure** | ✅ None required | Kubernetes, networking, storage |
| **Personnel** | ✅ None required | DevOps team needed |
| **Total Cost Profile** | Predictable and simple | Variable based on scale |
## Migration Path
<Note>
Most organizations start with SaaS configuration for quick deployment, then migrate to self-hosted later as requirements grow. This minimizes risk and ensures your infrastructure meets actual usage patterns.
</Note>
## Getting Started
<CardGroup cols={2}>
<Card title="Start with SaaS" icon="rocket" href="/enterprise-solutions/configuration/remote-configuration/overview">
Begin with quick SaaS setup
</Card>
<Card title="Deploy Self-Hosted" icon="server" href="/enterprise-solutions/configuration/infrastructure-configuration/overview">
Plan your infrastructure deployment
</Card>
</CardGroup>
## Need Help Deciding?
- [**Contact Cline Enterprise Sales**](https://cline.bot/contact-sales) for a consultation on your specific requirements
- [**Start with SaaS**](/enterprise-solutions/configuration/remote-configuration/overview) if unsure - it's lower risk and you can always migrate later
- [**Review Self-Hosted Requirements**](/enterprise-solutions/configuration/infrastructure-configuration/overview) if you have existing infrastructure that could benefit from self-hosted deployment
@@ -0,0 +1,35 @@
---
title: "Overview"
sidebarTitle: "Overview"
description: "Configure Cline settings for your enterprise deployment"
---
This section covers configuration options for controlling Cline's behavior in enterprise deployments.
## Available Settings
<Card title="YOLO Mode" icon="rocket" href="/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/yolo-mode">
Control enterprise access to autonomous operation mode with complete auto-approval
</Card>
## Configuration Methods
These settings can be configured through:
### Individual Users
- Users can toggle settings in their local Cline interface
- Enterprise policies can restrict certain settings
- Changes apply immediately to new tasks
## Enterprise Controls
Administrators can enforce policies through remote configuration:
```json
{
"yoloModeAllowed": false
}
```
When `yoloModeAllowed` is set to `false`, users cannot enable YOLO Mode in their local Cline interface.
@@ -0,0 +1,233 @@
---
title: "YOLO Mode"
sidebarTitle: "YOLO Mode"
description: "Enterprise controls for YOLO Mode autonomous operation"
---
YOLO Mode enables Cline to operate with complete autonomy, auto-approving all actions without user confirmation. For Enterprise administrators, this page covers how to control access to YOLO Mode across your organization.
<Note>
For complete details about YOLO Mode functionality, risks, and best practices, see [YOLO Mode in Features](/features/yolo-mode).
</Note>
## Overview
When YOLO Mode is enabled, Cline automatically approves all operations including file changes, terminal commands, browser actions, and mode transitions. This provides maximum automation speed but removes all safety guardrails.
<Warning>
YOLO Mode is powerful but potentially dangerous. Administrators should carefully consider which teams or users should have access to this feature.
</Warning>
## Enterprise Administrator Configuration
As an Enterprise administrator, you can control whether users in your organization can enable YOLO Mode through remote configuration.
### Disabling YOLO Mode for All Users
Add the following to your remote configuration JSON:
```json
{
"yoloModeAllowed": false
}
```
When `yoloModeAllowed` is set to `false`:
- The YOLO Mode toggle is disabled in all user interfaces
- Users cannot enable YOLO Mode even in their local settings
- This policy applies immediately to all team members
- Enterprise policy takes precedence over individual preferences
### Enabling YOLO Mode for All Users
```json
{
"yoloModeAllowed": true
}
```
When `yoloModeAllowed` is set to `true` or omitted:
- Users can enable or disable YOLO Mode in their local Cline settings
- Individual users make their own decisions about using YOLO Mode
- No organizational restrictions apply
## Enterprise Policy Recommendations
### Recommended Approach
Most organizations should **disable YOLO Mode by default** for the following reasons:
<AccordionGroup>
<Accordion title="Security & Compliance" icon="shield">
YOLO Mode removes all approval gates, potentially allowing:
- Unreviewed code changes to critical systems
- Execution of commands without oversight
- Automated actions that may violate compliance policies
- Risk of data exposure through unmonitored operations
</Accordion>
<Accordion title="Code Quality Control" icon="code">
Without approval prompts:
- Changes happen too quickly to review in real-time
- Mistakes can compound before detection
- Quality gates are bypassed
- Rollback becomes more complex
</Accordion>
<Accordion title="Audit Requirements" icon="clipboard-check">
Many industries require:
- Documented approval trails for code changes
- Clear accountability for automated actions
- Traceable decision-making processes
- YOLO Mode may conflict with these requirements
</Accordion>
</AccordionGroup>
### Exceptions: When to Allow YOLO Mode
Consider enabling YOLO Mode for:
**Sandbox/Development Environments**
- Isolated testing environments
- Personal development machines
- Proof-of-concept projects
- Temporary exploratory work
**Specialized Roles**
- DevOps automation engineers (with proper monitoring)
- Research & development teams in sandboxed environments
- Teams with robust rollback and recovery procedures
**Controlled Use Cases**
- Scripted CI/CD pipelines with comprehensive logging
- Automated testing scenarios
- Demonstration or training environments
## Enterprise Considerations
### Security Implications
When YOLO Mode is enabled in your organization:
**Risk Factors:**
- All tool executions happen automatically without human review
- Potential for rapid propagation of mistakes across multiple files
- Reduced opportunity to catch security vulnerabilities before implementation
- Automated operations may bypass existing security controls
**Mitigations:**
- Implement comprehensive logging and monitoring
- Restrict YOLO Mode to non-production environments
- Require periodic security reviews for teams using YOLO Mode
- Ensure version control and rollback procedures are in place
### Monitoring Requirements
When allowing YOLO Mode in your organization, implement:
**Mandatory Monitoring:**
1. **Real-time Activity Tracking**
- Monitor which users enable YOLO Mode
- Track when YOLO Mode is active
- Log all automated actions taken
2. **Audit Trail Maintenance**
- Preserve complete history of YOLO Mode sessions
- Document what was automated and when
- Maintain records for compliance purposes
3. **Anomaly Detection**
- Alert on unusual patterns of automated actions
- Flag high-risk operations performed automatically
- Monitor for potential security incidents
### Monitoring YOLO Mode Usage
When YOLO Mode is enabled (by policy), track usage through:
**Telemetry Events:**
- Captures when users toggle YOLO Mode on/off
- Records which tasks were executed with YOLO Mode enabled
- Provides aggregate usage statistics across your organization
**Task History:**
- Task metadata indicates whether YOLO Mode was active
- Complete action logs show automated approvals
- Enables post-action review and analysis
**Audit Logs:**
- Standard logging captures all automated decisions
- Tool executions are recorded with timestamps
- Provides compliance trail for regulated environments
## Recommended Policies by Organization Size
### Small Teams (5-20 developers)
- **Default:** Disabled
- **Exceptions:** Allow for individual sandbox environments
- **Monitoring:** Basic telemetry sufficient
### Medium Organizations (20-100 developers)
- **Default:** Disabled
- **Exceptions:** Permit for designated dev/test environments only
- **Monitoring:** Required telemetry + regular audit reviews
### Large Enterprises (100+ developers)
- **Default:** Strictly disabled
- **Exceptions:** Require security approval for each use case
- **Monitoring:** Comprehensive telemetry + real-time alerting + compliance reporting
## Technical Implementation
### Configuration Management
**Centralized Control through Remote Configuration:**
```json
{
"yoloModeAllowed": false,
// Other policies...
}
```
This setting:
- Applies instantly to all connected clients
- Cannot be overridden by individual users
- Persists across Cline restarts
- Is synchronized across all team members
### Policy Enforcement
The enforcement mechanism:
1. Users authenticate with your enterprise configuration server
2. Remote configuration is downloaded and applied
3. Local UI respects enterprise policy settings
4. YOLO Mode toggle is disabled if policy forbids it
5. Users see a message explaining the enterprise restriction
## Compliance Considerations
For organizations in regulated industries:
**SOC 2 Compliance:**
- YOLO Mode may conflict with change management controls
- Document decision to allow/disallow in security policies
- Implement compensating controls if YOLO Mode is permitted
**GDPR/Data Protection:**
- Automated operations must still respect data handling policies
- Ensure YOLO Mode doesn't bypass data protection safeguards
- Maintain audit trails of automated data processing
**Industry-Specific:**
- Financial services: Generally incompatible with Reg requirements
- Healthcare: May violate HIPAA audit trail requirements
- Government: Often conflicts with approval workflow mandates
## Support & Questions
For help configuring YOLO Mode policies:
- Review [Remote Configuration Overview](/enterprise-solutions/configuration/remote-configuration/overview)
- See [Features: YOLO Mode](/features/yolo-mode) for detailed functionality
- Contact your Enterprise support representative
- Join our [Discord](https://discord.gg/cline) for community discussion
@@ -0,0 +1,565 @@
---
title: "MCP Marketplace"
sidebarTitle: "MCP Marketplace"
description: "Deploy pre-built enterprise MCP servers from the Cline marketplace with one-click configuration"
---
The MCP Marketplace provides curated, enterprise-ready integrations with popular development tools and services. All marketplace servers are built with enterprise security, compliance, and scalability in mind.
## Enterprise Marketplace Benefits
<CardGroup cols={2}>
<Card title="One-Click Deployment" icon="rocket">
Deploy complex integrations instantly with pre-configured enterprise settings.
</Card>
<Card title="Security Hardened" icon="shield-check">
All servers include enterprise security features, audit logging, and compliance controls.
</Card>
<Card title="Maintained & Updated" icon="sync">
Regular security updates and feature enhancements managed by Cline Enterprise team.
</Card>
<Card title="Enterprise Support" icon="headset">
Dedicated support channels for marketplace integration issues and customization.
</Card>
</CardGroup>
## Available Integrations
### Development Tools
<CardGroup cols={3}>
<Card title="GitHub Enterprise" icon="github">
Repository management, issue tracking, PR workflows, and code analysis
</Card>
<Card title="GitLab Enterprise" icon="gitlab">
Project management, CI/CD pipelines, merge requests, and security scanning
</Card>
<Card title="Bitbucket Enterprise" icon="bitbucket">
Source code management, build pipelines, and deployment automation
</Card>
</CardGroup>
### Project Management
<CardGroup cols={3}>
<Card title="Jira Enterprise" icon="jira">
Issue tracking, sprint management, custom fields, and workflow automation
</Card>
<Card title="Azure DevOps" icon="microsoft">
Work items, boards, repos, pipelines, and test management
</Card>
<Card title="Linear" icon="linear">
Issue tracking, project planning, and development workflow integration
</Card>
</CardGroup>
### Communication & Collaboration
<CardGroup cols={3}>
<Card title="Slack Enterprise Grid" icon="slack">
Notifications, bot interactions, file sharing, and workflow automation
</Card>
<Card title="Microsoft Teams" icon="microsoft-teams">
Chat notifications, meeting integration, and collaborative workflows
</Card>
<Card title="Discord" icon="discord">
Community management, bot interactions, and developer notifications
</Card>
</CardGroup>
### Cloud Services
<CardGroup cols={3}>
<Card title="AWS Services" icon="aws">
EC2, S3, Lambda, RDS, CloudWatch, and other AWS service integrations
</Card>
<Card title="Google Cloud" icon="google-cloud">
Compute Engine, Cloud Storage, BigQuery, and GCP service management
</Card>
<Card title="Azure Services" icon="azure">
Virtual Machines, Storage Accounts, Functions, and Azure resource management
</Card>
</CardGroup>
## Installing Marketplace Servers
### Via Cline Enterprise Dashboard
1. **Access Marketplace**: Navigate to `Settings > Enterprise > MCP Marketplace`
2. **Browse Integrations**: Filter by category, popularity, or search by name
3. **Review Details**: Check compatibility, permissions, and configuration requirements
4. **Install**: Click "Install" and configure required settings
5. **Deploy**: Approve deployment to your selected environment
### Via Configuration File
Install marketplace servers through enterprise configuration:
```yaml
# enterprise-mcp-config.yaml
mcp:
marketplace_servers:
- name: "github-enterprise"
package: "@cline/mcp-github-enterprise"
version: "2.1.0"
environment: "production"
config:
github:
base_url: "https://github.company.com/api/v3"
token: "${GITHUB_ENTERPRISE_TOKEN}"
organization: "company"
features:
issue_management: true
pull_request_automation: true
code_analysis: true
security_scanning: true
permissions:
repositories: "read-write"
issues: "write"
pull_requests: "write"
compliance:
audit_logging: true
data_retention_days: 365
encryption_at_rest: true
- name: "jira-enterprise"
package: "@cline/mcp-jira-enterprise"
version: "1.8.3"
environment: "production"
config:
jira:
base_url: "https://company.atlassian.net"
username: "${JIRA_USERNAME}"
api_token: "${JIRA_API_TOKEN}"
projects:
- key: "DEV"
permissions: ["read", "write", "transition"]
- key: "OPS"
permissions: ["read", "comment"]
compliance:
field_encryption: ["description", "comments"]
audit_trail: true
```
### Via CLI
Deploy using the Cline Enterprise CLI:
```bash
# Install GitHub Enterprise integration
cline-enterprise mcp install github-enterprise \
--version 2.1.0 \
--config-file github-config.yaml \
--environment production
# Install Slack Enterprise Grid integration
cline-enterprise mcp install slack-enterprise-grid \
--version 1.5.2 \
--config workspace_id=T1234567890 \
--config bot_token=${SLACK_BOT_TOKEN} \
--environment production
# List installed marketplace servers
cline-enterprise mcp list --environment production
# Check server status
cline-enterprise mcp status github-enterprise --environment production
```
## Configuration Examples
### GitHub Enterprise Integration
```yaml
# github-enterprise-config.yaml
github:
base_url: "https://github.company.com/api/v3"
token: "${GITHUB_ENTERPRISE_TOKEN}"
organization: "company"
# Repository access controls
repositories:
allowed_patterns:
- "company/*"
- "internal/*"
blocked_patterns:
- "*/secrets"
- "*/private-keys"
# Feature configuration
features:
issue_management:
enabled: true
auto_assign: true
labels:
- "ai-generated"
- "cline-task"
pull_requests:
enabled: true
auto_review_request: true
required_approvals: 2
enforce_branch_protection: true
code_analysis:
enabled: true
languages: ["typescript", "python", "go", "rust"]
security_scan: true
# Security and compliance
security:
webhook_secret: "${GITHUB_WEBHOOK_SECRET}"
rate_limiting:
requests_per_hour: 5000
burst_limit: 100
ip_whitelist:
- "10.0.0.0/8"
- "192.168.0.0/16"
audit:
log_level: "INFO"
include_payloads: false
retention_days: 365
destinations: ["datadog", "splunk"]
```
### Jira Enterprise Integration
```yaml
# jira-enterprise-config.yaml
jira:
base_url: "https://company.atlassian.net"
username: "${JIRA_USERNAME}"
api_token: "${JIRA_API_TOKEN}"
# Project access configuration
projects:
- key: "DEV"
name: "Development"
permissions: ["read", "write", "transition", "assign"]
issue_types: ["Story", "Bug", "Task", "Subtask"]
- key: "OPS"
name: "Operations"
permissions: ["read", "comment", "watch"]
# Custom field mappings
custom_fields:
story_points: "customfield_10002"
epic_link: "customfield_10014"
sprint: "customfield_10020"
# Workflow automation
automation:
auto_transition:
enabled: true
rules:
- from_status: "To Do"
to_status: "In Progress"
condition: "assignee_changed"
auto_assign:
enabled: true
rules:
- issue_type: "Bug"
component: "Frontend"
assignee: "frontend-team-lead"
# Security and compliance
security:
encrypt_fields: ["description", "comment"]
mask_sensitive_data: true
audit_changes: true
compliance:
gdpr_compliant: true
data_retention_policy: "365_days"
audit_log_retention: "7_years"
```
### Slack Enterprise Grid Integration
```yaml
# slack-enterprise-config.yaml
slack:
workspace_id: "T1234567890"
bot_token: "${SLACK_BOT_TOKEN}"
signing_secret: "${SLACK_SIGNING_SECRET}"
# Channel management
channels:
notifications:
- name: "#dev-alerts"
types: ["deployments", "errors", "security"]
- name: "#ai-activity"
types: ["cline-tasks", "completions"]
private_channels:
- name: "#security-incidents"
members: ["security-team"]
types: ["security-alerts", "compliance-issues"]
# Bot behavior
bot:
display_name: "Cline Enterprise"
default_channel: "#general"
response_delay_ms: 1000
commands:
- command: "/cline-status"
description: "Check Cline Enterprise status"
permission: "all"
- command: "/cline-deploy"
description: "Trigger deployment"
permission: "admin"
# Enterprise features
enterprise:
app_approval_required: true
data_residency: "US"
compliance_export: true
dlp:
enabled: true
scan_messages: true
block_sensitive_data: true
# Security settings
security:
require_app_approval: true
audit_api_calls: true
encrypt_messages: true
retain_audit_logs_days: 2555 # 7 years
```
## Enterprise Management
### Multi-Environment Deployment
Deploy marketplace servers across environments:
```yaml
# environments-config.yaml
environments:
development:
marketplace_servers:
- github-enterprise:
version: "2.1.0-beta"
config_override:
github:
base_url: "https://github-dev.company.com/api/v3"
organization: "company-dev"
staging:
marketplace_servers:
- github-enterprise:
version: "2.1.0-rc1"
config_override:
github:
base_url: "https://github-staging.company.com/api/v3"
organization: "company-staging"
production:
marketplace_servers:
- github-enterprise:
version: "2.1.0"
config_override:
github:
base_url: "https://github.company.com/api/v3"
organization: "company"
```
### Version Management
Control marketplace server versions:
```bash
# List available versions
cline-enterprise mcp versions github-enterprise
# Upgrade to latest version
cline-enterprise mcp upgrade github-enterprise --version 2.2.0 --environment staging
# Rollback to previous version
cline-enterprise mcp rollback github-enterprise --version 2.1.0 --environment staging
# Pin to specific version (disable auto-updates)
cline-enterprise mcp pin github-enterprise --version 2.1.0
```
### Health Monitoring
Monitor marketplace server health:
```yaml
# monitoring-config.yaml
monitoring:
marketplace_servers:
health_checks:
interval_seconds: 30
timeout_seconds: 10
metrics:
- server_status
- request_latency
- error_rate
- resource_usage
alerts:
- name: "marketplace-server-down"
condition: "server_status != 1"
severity: "critical"
- name: "high-error-rate"
condition: "error_rate > 0.05"
severity: "warning"
- name: "performance-degradation"
condition: "request_latency > 5s"
severity: "warning"
```
## Security & Compliance
### Enterprise Security Features
All marketplace servers include:
- **Authentication Integration**: SSO, SAML, OAuth2 support
- **Authorization Controls**: RBAC and fine-grained permissions
- **Audit Logging**: Comprehensive activity tracking
- **Data Encryption**: At-rest and in-transit encryption
- **Network Security**: VPN, IP whitelisting, private endpoints
- **Compliance**: SOC2, GDPR, HIPAA compliance frameworks
### Data Governance
Configure data handling policies:
```yaml
# data-governance-config.yaml
data_governance:
classification:
public:
retention_days: 90
backup_required: false
internal:
retention_days: 365
backup_required: true
encryption_required: false
confidential:
retention_days: 2555 # 7 years
backup_required: true
encryption_required: true
audit_access: true
restricted:
retention_days: 2555
backup_required: true
encryption_required: true
audit_access: true
approval_required: true
privacy:
pii_detection: true
pii_masking: true
gdpr_compliance: true
data_subject_requests: true
compliance:
frameworks: ["SOC2", "GDPR", "CCPA", "HIPAA"]
audit_frequency: "quarterly"
certification_renewal: "annual"
```
## Best Practices
### Installation
1. **Review Permissions**: Always review required permissions before installation
2. **Test in Staging**: Deploy to staging environment first
3. **Configuration Validation**: Validate configuration files before deployment
4. **Backup Current State**: Create configuration backups before changes
5. **Monitor Deployment**: Watch health metrics during rollout
### Configuration
1. **Environment Separation**: Use different configurations per environment
2. **Secret Management**: Store sensitive data in secure secret stores
3. **Version Pinning**: Pin versions for production deployments
4. **Access Controls**: Implement least-privilege access policies
5. **Regular Updates**: Schedule regular security and feature updates
### Monitoring
1. **Health Checks**: Monitor server health continuously
2. **Performance Metrics**: Track latency and throughput
3. **Error Tracking**: Alert on error rates and failure patterns
4. **Resource Usage**: Monitor CPU, memory, and network usage
5. **Audit Reviews**: Regular review of audit logs and access patterns
## Troubleshooting
### Common Issues
**Installation Failures**:
```bash
# Check marketplace connectivity
cline-enterprise mcp marketplace-status
# Verify authentication
cline-enterprise auth verify --service marketplace
# Check installation logs
cline-enterprise logs mcp-installer --lines 100
```
**Configuration Errors**:
```bash
# Validate configuration
cline-enterprise mcp validate-config --file config.yaml
# Test connectivity
cline-enterprise mcp test-connection github-enterprise --environment staging
# Check server status
cline-enterprise mcp status --all
```
**Performance Issues**:
```bash
# Check server metrics
cline-enterprise mcp metrics github-enterprise --duration 1h
# View recent error logs
cline-enterprise logs github-enterprise --level error --lines 50
```
## Support
For marketplace server issues:
- **Documentation**: Check server-specific documentation in the dashboard
- **Community**: Join the Cline Enterprise community forum
- **Support Tickets**: Create support tickets for critical issues
- **Professional Services**: Engage professional services for custom configurations
Enterprise customers have access to dedicated support channels with SLA guarantees.
@@ -0,0 +1,571 @@
---
title: "MCP Integration"
sidebarTitle: "Overview"
description: "Configure Model Context Protocol (MCP) servers and marketplace integrations for enterprise Cline deployments"
---
Model Context Protocol (MCP) provides standardized communication between AI models and external data sources, tools, and services. Enterprise MCP integration allows you to securely connect Cline to your organization's systems while maintaining governance and compliance.
## Enterprise MCP Benefits
<CardGroup cols={2}>
<Card title="Extensible Architecture" icon="puzzle-piece">
Connect to unlimited external tools, databases, APIs, and services through standardized MCP servers.
</Card>
<Card title="Enterprise Security" icon="shield-alt">
Secure authentication, authorization, and audit trails for all MCP server communications.
</Card>
<Card title="Centralized Management" icon="network-wired">
Manage and deploy MCP servers enterprise-wide with version control and configuration management.
</Card>
<Card title="Compliance Ready" icon="clipboard-check">
Built-in logging, monitoring, and data governance for regulatory compliance requirements.
</Card>
</CardGroup>
## MCP Architecture Overview
```mermaid
graph TB
A[Cline Enterprise] --> B[MCP Hub]
B --> C[MCP Marketplace]
B --> D[Remote MCP Servers]
B --> E[Internal MCP Servers]
C --> F[GitHub Integration]
C --> G[Slack Integration]
C --> H[Jira Integration]
D --> I[Custom APIs]
D --> J[Databases]
D --> K[Cloud Services]
E --> L[Internal Tools]
E --> M[Legacy Systems]
E --> N[Security Systems]
O[Enterprise Admin] --> B
P[Audit Logging] --> B
Q[Authentication] --> B
```
## Core Components
<CardGroup cols={2}>
<Card title="MCP Marketplace" icon="store" href="/enterprise-solutions/configuration/infrastructure-configuration/mcp/mcp-marketplace">
Pre-built, enterprise-ready MCP servers for popular tools and services with one-click deployment.
</Card>
<Card title="Remote MCP Servers" icon="server" href="/enterprise-solutions/configuration/infrastructure-configuration/mcp/remote-mcp-servers">
Deploy and manage custom MCP servers across your infrastructure with centralized configuration.
</Card>
</CardGroup>
## Enterprise Configuration
### Basic MCP Hub Setup
Configure the central MCP hub for your enterprise deployment:
```yaml
# mcp-hub-config.yaml
mcp:
hub:
enabled: true
port: 8080
authentication:
method: "enterprise-sso"
jwt_secret: "${MCP_JWT_SECRET}"
# Server discovery
discovery:
methods: ["marketplace", "remote", "local"]
marketplace_url: "https://mcp.cline.bot/marketplace"
# Security settings
security:
enforce_tls: true
allowed_origins: ["https://*.company.com"]
rate_limiting:
requests_per_minute: 1000
burst_size: 100
# Audit and compliance
audit:
enabled: true
log_level: "INFO"
destinations: ["file", "syslog", "datadog"]
retention_days: 90
```
### Multi-Environment Configuration
Deploy MCP configurations across environments:
<Tabs>
<Tab title="Development">
```yaml
# mcp-dev-config.yaml
mcp:
environment: "development"
servers:
- name: "github-dev"
type: "marketplace"
package: "@cline/mcp-github"
version: "latest"
config:
github_token: "${GITHUB_DEV_TOKEN}"
org: "company-dev"
- name: "local-db"
type: "remote"
url: "http://localhost:3001"
auth:
type: "api-key"
key: "${DEV_DB_API_KEY}"
policies:
allow_experimental: true
auto_update: true
rate_limits:
relaxed: true
```
</Tab>
<Tab title="Production">
```yaml
# mcp-prod-config.yaml
mcp:
environment: "production"
servers:
- name: "github-prod"
type: "marketplace"
package: "@cline/mcp-github"
version: "1.2.3" # Pinned version
config:
github_token: "${GITHUB_PROD_TOKEN}"
org: "company"
- name: "crm-integration"
type: "remote"
url: "https://mcp-crm.internal.company.com"
auth:
type: "mtls"
cert_path: "/certs/mcp-client.pem"
key_path: "/certs/mcp-client-key.pem"
- name: "security-scanner"
type: "remote"
url: "https://security-mcp.company.com"
auth:
type: "oauth2"
client_id: "${SECURITY_CLIENT_ID}"
client_secret: "${SECURITY_CLIENT_SECRET}"
policies:
allow_experimental: false
auto_update: false
strict_versioning: true
monitoring:
metrics: true
health_checks: true
alert_on_failure: true
```
</Tab>
</Tabs>
## Server Management
### Lifecycle Management
Manage MCP server deployments with GitOps:
```yaml
# mcp-server-manifest.yaml
apiVersion: mcp.cline.bot/v1
kind: MCPServer
metadata:
name: custom-api-server
namespace: cline-enterprise
spec:
image: company/custom-mcp-server:v1.0.0
replicas: 3
config:
api_endpoint: "https://api.internal.company.com"
timeout: 30s
retry_attempts: 3
auth:
type: service-account
service_account: mcp-custom-api
resources:
requests:
memory: "256Mi"
cpu: "100m"
limits:
memory: "512Mi"
cpu: "500m"
monitoring:
enabled: true
metrics_port: 9090
health_endpoint: "/health"
security:
network_policy: strict
pod_security_standard: restricted
```
### Configuration Management
Use Helm charts for enterprise MCP deployments:
```yaml
# values-prod.yaml
mcp:
hub:
replicaCount: 3
image:
repository: cline/mcp-hub-enterprise
tag: "1.5.2"
servers:
marketplace:
enabled: true
catalog_url: "https://enterprise-catalog.company.com"
custom:
- name: "salesforce"
enabled: true
image: "company/mcp-salesforce:1.0.0"
config:
instance_url: "https://company.my.salesforce.com"
- name: "jira"
enabled: true
image: "company/mcp-jira:2.1.0"
config:
base_url: "https://company.atlassian.net"
ingress:
enabled: true
className: nginx
annotations:
cert-manager.io/cluster-issuer: "letsencrypt-prod"
hosts:
- host: mcp.company.com
paths:
- path: /
pathType: Prefix
tls:
- secretName: mcp-tls
hosts:
- mcp.company.com
```
## Security & Governance
### Authentication & Authorization
Configure enterprise authentication for MCP servers:
```yaml
# mcp-auth-config.yaml
authentication:
providers:
- name: "enterprise-sso"
type: "oidc"
issuer: "https://sso.company.com"
client_id: "${SSO_CLIENT_ID}"
client_secret: "${SSO_CLIENT_SECRET}"
- name: "service-accounts"
type: "jwt"
signing_key: "${SERVICE_ACCOUNT_KEY}"
authorization:
policies:
- name: "developers"
subjects: ["group:developers"]
resources: ["mcp:servers:read", "mcp:servers:execute"]
- name: "admins"
subjects: ["group:mcp-admins"]
resources: ["mcp:*"]
- name: "security-team"
subjects: ["group:security"]
resources: ["mcp:audit:*", "mcp:servers:security-*"]
rbac:
enabled: true
default_role: "viewer"
```
### Network Security
Implement network policies for MCP communications:
```yaml
# mcp-network-policy.yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: mcp-server-policy
namespace: cline-enterprise
spec:
podSelector:
matchLabels:
app: mcp-server
policyTypes:
- Ingress
- Egress
ingress:
- from:
- namespaceSelector:
matchLabels:
name: cline-enterprise
- podSelector:
matchLabels:
app: cline-core
ports:
- protocol: TCP
port: 8080
egress:
# Allow DNS
- to: []
ports:
- protocol: UDP
port: 53
# Allow HTTPS to external APIs
- to: []
ports:
- protocol: TCP
port: 443
```
## Monitoring & Observability
### Metrics Collection
Configure comprehensive MCP monitoring:
```yaml
# mcp-monitoring.yaml
monitoring:
metrics:
enabled: true
interval: 30s
collectors:
- name: "server-health"
metrics:
- mcp_server_status
- mcp_server_response_time
- mcp_server_error_rate
- name: "hub-performance"
metrics:
- mcp_hub_requests_total
- mcp_hub_request_duration
- mcp_hub_active_connections
- name: "resource-usage"
metrics:
- mcp_memory_usage
- mcp_cpu_usage
- mcp_network_io
alerts:
- name: "server-down"
condition: "mcp_server_status == 0"
severity: "critical"
notification_channels: ["pagerduty", "slack"]
- name: "high-error-rate"
condition: "mcp_server_error_rate > 0.05"
severity: "warning"
notification_channels: ["slack"]
- name: "performance-degradation"
condition: "mcp_server_response_time > 5s"
severity: "warning"
notification_channels: ["email"]
```
### Audit Logging
Implement comprehensive audit trails:
```json
{
"timestamp": "2024-01-15T10:30:00Z",
"event_type": "mcp_server_call",
"user_id": "john.doe@company.com",
"session_id": "sess_abc123",
"server_name": "github-prod",
"method": "github.create_issue",
"request": {
"repository": "company/project",
"title": "Bug fix required",
"sensitive_data_detected": false
},
"response": {
"status": "success",
"issue_id": "12345",
"duration_ms": 234
},
"compliance": {
"data_classification": "internal",
"retention_required": true,
"pii_detected": false
}
}
```
## Custom MCP Server Development
### Development Framework
Create custom MCP servers using the enterprise SDK:
```typescript
// custom-mcp-server.ts
import { MCPServer, Tool, Resource } from '@cline/mcp-enterprise-sdk';
class CustomAPIServer extends MCPServer {
constructor() {
super({
name: 'custom-api-server',
version: '1.0.0',
description: 'Custom API integration server'
});
this.addTool(new DatabaseQueryTool());
this.addResource(new UserDataResource());
}
}
class DatabaseQueryTool implements Tool {
name = 'query_database';
description = 'Query the company database';
async execute(params: any) {
// Implement database query logic
const result = await this.database.query(params.sql);
// Audit log the query
await this.auditLog({
action: 'database_query',
query: params.sql,
user: params.user_id,
results_count: result.length
});
return result;
}
async validate(params: any): Promise<boolean> {
// Implement query validation
return params.sql && !this.containsMaliciousSQL(params.sql);
}
}
```
### Deployment Pipeline
Automate MCP server deployments:
```yaml
# .github/workflows/deploy-mcp-server.yml
name: Deploy MCP Server
on:
push:
branches: [main]
paths: ['mcp-servers/**']
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Build MCP Server
run: |
docker build -t company/mcp-server:${{ github.sha }} .
docker push company/mcp-server:${{ github.sha }}
- name: Deploy to Staging
run: |
helm upgrade mcp-server-staging ./helm-chart \
--set image.tag=${{ github.sha }} \
--namespace mcp-staging
- name: Run Integration Tests
run: |
kubectl wait --for=condition=ready pod -l app=mcp-server -n mcp-staging
npm run test:integration
- name: Deploy to Production
if: success()
run: |
helm upgrade mcp-server-prod ./helm-chart \
--set image.tag=${{ github.sha }} \
--namespace mcp-prod
```
## Best Practices
### Security
1. **Authentication**: Always require authentication for MCP servers
2. **Encryption**: Use TLS for all MCP communications
3. **Validation**: Validate all inputs and sanitize outputs
4. **Least Privilege**: Grant minimal required permissions
5. **Audit**: Log all MCP server interactions
### Performance
1. **Caching**: Implement response caching where appropriate
2. **Connection Pooling**: Reuse connections to external services
3. **Async Operations**: Use non-blocking operations for I/O
4. **Resource Limits**: Set appropriate CPU and memory limits
5. **Load Balancing**: Scale MCP servers based on demand
### Reliability
1. **Health Checks**: Implement comprehensive health endpoints
2. **Circuit Breakers**: Fail fast when external services are down
3. **Retry Logic**: Implement exponential backoff for failures
4. **Graceful Degradation**: Provide fallback behavior
5. **Monitoring**: Set up proactive alerting and monitoring
## Production Checklist
Before deploying MCP servers to production:
- [ ] Security review completed
- [ ] Authentication and authorization configured
- [ ] Network policies implemented
- [ ] Monitoring and alerting set up
- [ ] Audit logging enabled
- [ ] Resource limits configured
- [ ] Health checks implemented
- [ ] Integration tests passing
- [ ] Disaster recovery plan documented
- [ ] Compliance requirements validated
## Getting Started
Ready to implement enterprise MCP integration? Start with:
1. [MCP Marketplace](/enterprise-solutions/configuration/infrastructure-configuration/mcp/mcp-marketplace) - Deploy pre-built integrations
2. [Remote MCP Servers](/enterprise-solutions/configuration/infrastructure-configuration/mcp/remote-mcp-servers) - Configure custom servers
3. Review our [MCP Development Guide](/mcp/mcp-overview) for building custom integrations
@@ -0,0 +1,95 @@
---
title: "Self-Hosted Configuration"
sidebarTitle: "Overview"
description: "Deploy and configure Cline on your own infrastructure with enterprise-grade security and compliance"
---
<Warning>
**Self-Hosted Configuration Path**
This section is for enterprises deploying **self-hosted Cline infrastructure** with complex security, compliance, and multi-environment requirements. Configuration is done through YAML files, Kubernetes/Helm deployments, and infrastructure-as-code.
**Looking for simple setup?** See [SaaS Provider Configuration](/enterprise-solutions/configuration/remote-configuration/overview) for quick configuration through the app.cline.bot admin console - no infrastructure deployment required, just web-based settings.
</Warning>
Self-Hosted Configuration provides centralized control over all aspects of your Cline deployment on your own infrastructure, from AI providers to custom workflows. This section covers how to configure, manage, and optimize your enterprise Cline installation with advanced security, compliance, and operational features.
## Configuration Categories
<CardGroup cols={2}>
<Card title="Providers" icon="cloud" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/overview">
Configure AI providers including AWS Bedrock, LiteLLM, and Google Vertex AI with enterprise-grade security and governance.
</Card>
<Card title="MCP Integration" icon="plug" href="/enterprise-solutions/configuration/infrastructure-configuration/mcp/overview">
Manage Model Context Protocol servers, marketplace integrations, and remote MCP server configurations.
</Card>
<Card title="Rules Engine" icon="shield-check" href="/enterprise-solutions/configuration/infrastructure-configuration/rules">
Define and enforce enterprise governance rules, security policies, and compliance requirements.
</Card>
<Card title="Workflows" icon="workflow" href="/enterprise-solutions/configuration/infrastructure-configuration/workflows">
Create automated workflows for development processes, approval chains, and integration pipelines.
</Card>
</CardGroup>
## Advanced Controls
<CardGroup cols={2}>
<Card title="Control Other Cline Features" icon="toggles" href="/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/overview">
Enable or disable specific Cline features across your organization with granular permission controls.
</Card>
<Card title="Monitoring" icon="chart-line" href="/enterprise-solutions/monitoring/overview">
Configure OpenTelemetry integration for comprehensive monitoring, logging, and analytics.
</Card>
</CardGroup>
## Getting Started
1. **Assessment**: Review your current infrastructure and integration requirements
2. **Provider Setup**: Configure your preferred AI providers with enterprise credentials
3. **Security Configuration**: Implement rules and access controls
4. **Monitoring Setup**: Enable telemetry and monitoring for operational visibility
5. **User Onboarding**: Deploy configurations to your development teams
## Enterprise Architecture Considerations
### Security & Compliance
- **Zero Trust Architecture**: All configurations support zero-trust security models
- **Audit Logging**: Complete audit trails for all configuration changes
- **Role-Based Access**: Granular permissions for different administrative roles
- **Data Sovereignty**: Keep sensitive data within your infrastructure boundaries
### Scalability & Performance
- **Multi-Region Support**: Deploy configurations across multiple geographic regions
- **Load Balancing**: Distribute AI provider requests across multiple endpoints
- **Caching Strategies**: Optimize performance with intelligent caching
- **Rate Limiting**: Prevent abuse with configurable rate limits
### Integration & Automation
- **GitOps Integration**: Version control your configurations alongside code
- **CI/CD Pipeline Integration**: Automate configuration deployment
- **Webhook Support**: React to configuration changes with custom automation
- **API-First Design**: Programmatically manage all configurations
## Configuration Management
All enterprise configurations support:
- **Version Control**: Track changes with full revision history
- **Environment Promotion**: Deploy configurations from dev → staging → production
- **Rollback Capabilities**: Quickly revert problematic configurations
- **Configuration Validation**: Automated testing of configuration changes
- **Drift Detection**: Monitor and alert on configuration drift
## Next Steps
Ready to configure your enterprise deployment? Start with:
1. [Provider Configuration](/enterprise-solutions/configuration/infrastructure-configuration/providers/overview) - Set up your AI providers
2. [Security Rules](/enterprise-solutions/configuration/infrastructure-configuration/rules) - Implement governance policies
3. [Monitoring Setup](/enterprise-solutions/monitoring/overview) - Enable operational visibility
For hands-on configuration assistance, contact your Cline Enterprise support team or refer to our implementation guides.
@@ -0,0 +1,182 @@
---
title: "AWS Bedrock Configuration"
sidebarTitle: "AWS Bedrock"
description: "Configure AWS Bedrock for your Cline deployment"
---
<Info>
**Configuration Path: Self-Hosted**
This guide covers Bedrock configuration for self-hosted deployments. For simple web-based setup, see [AWS Bedrock SaaS Configuration](/enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration).
</Info>
Configure Cline to use AWS Bedrock for enterprise access to Claude and other foundation models through Amazon's managed service.
## Configuration Format
Configure Bedrock through your remote configuration JSON using the `providerSettings.AwsBedrock` section:
```json
{
"providerSettings": {
"AwsBedrock": {
"models": [
{
"id": "anthropic.claude-3-5-sonnet-20241022-v2:0",
"name": "Claude 3.5 Sonnet"
}
],
"awsRegion": "us-east-1"
}
}
}
```
## Configuration Fields
| Field | Type | Description | Required |
|-------|------|-------------|----------|
| `models` | Array | List of model configurations | Yes |
| `awsRegion` | String | AWS region (e.g., `us-east-1`) | Yes |
| `awsUseCrossRegionInference` | Boolean | Enable cross-region inference | No |
| `awsUseGlobalInference` | Boolean | Enable global inference routing | No |
| `awsBedrockUsePromptCache` | Boolean | Enable prompt caching | No |
| `awsBedrockEndpoint` | String | Custom Bedrock endpoint URL | No |
| `customModels` | Array | Custom model configurations | No |
### Model Configuration
Each model in the `models` array requires:
```json
{
"id": "anthropic.claude-3-5-sonnet-20241022-v2:0",
"name": "Claude 3.5 Sonnet",
"info": {
"maxTokens": 8192,
"contextWindow": 200000,
"supportsImages": true,
"supportsPromptCache": true
}
}
```
## Common Model IDs
| Model ID | Description | Context Window |
|----------|-------------|----------------|
| `anthropic.claude-3-5-sonnet-20241022-v2:0` | Latest Claude Sonnet | 200K tokens |
| `anthropic.claude-3-5-haiku-20241022-v1:0` | Latest Claude Haiku | 200K tokens |
| `anthropic.claude-3-opus-20240229-v1:0` | Claude Opus | 200K tokens |
<Note>
Model availability varies by region. See [AWS Bedrock documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) for region-specific model availability.
</Note>
## Example Configurations
### Basic Configuration
```json
{
"providerSettings": {
"AwsBedrock": {
"models": [
{
"id": "anthropic.claude-3-5-sonnet-20241022-v2:0",
"name": "Claude 3.5 Sonnet"
}
],
"awsRegion": "us-east-1"
}
}
}
```
### With Prompt Caching
```json
{
"providerSettings": {
"AwsBedrock": {
"models": [
{
"id": "anthropic.claude-3-5-sonnet-20241022-v2:0",
"name": "Claude 3.5 Sonnet"
}
],
"awsRegion": "us-east-1",
"awsBedrockUsePromptCache": true
}
}
}
```
### Multiple Models
```json
{
"providerSettings": {
"AwsBedrock": {
"models": [
{
"id": "anthropic.claude-3-5-sonnet-20241022-v2:0",
"name": "Claude 3.5 Sonnet"
},
{
"id": "anthropic.claude-3-5-haiku-20241022-v1:0",
"name": "Claude 3.5 Haiku"
}
],
"awsRegion": "us-east-1"
}
}
}
```
## Prerequisites
Before configuring Cline to use Bedrock, you need:
1. **AWS Account** with Bedrock access enabled
2. **IAM Permissions** for Bedrock API calls (`bedrock:InvokeModel`, `bedrock:InvokeModelWithResponseStream`)
3. **Model Access** enabled for desired models in the Bedrock console
4. **AWS Credentials** configured (IAM role, access keys, or AWS profile)
<Tip>
For AWS account setup and IAM configuration, see the [AWS Bedrock documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html).
</Tip>
## Troubleshooting
**"Access Denied" Errors**
Ensure your AWS credentials have the required Bedrock permissions. See [AWS IAM documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html) for permission requirements.
**"Model Not Found" Errors**
Verify model access is enabled in the AWS Bedrock console and the model is available in your configured region.
**High Latency**
Consider using a region closer to your users or enabling cross-region inference for better performance.
## Related Resources
<CardGroup cols={2}>
<Card title="AWS Bedrock Docs" icon="book" href="https://docs.aws.amazon.com/bedrock/">
Complete AWS Bedrock documentation
</Card>
<Card title="Model Access" icon="key" href="https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html">
How to enable model access
</Card>
<Card title="IAM Permissions" icon="shield" href="https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html">
Required IAM permissions
</Card>
<Card title="Pricing" icon="dollar-sign" href="https://aws.amazon.com/bedrock/pricing/">
AWS Bedrock pricing details
</Card>
</CardGroup>
@@ -0,0 +1,254 @@
---
title: "Custom Provider Configuration"
sidebarTitle: "Custom Providers"
description: "Configure custom OpenAI-compatible providers for your Cline deployment"
---
<Info>
**Configuration Path: Self-Hosted**
This guide covers custom provider configuration for self-hosted deployments.
</Info>
Configure Cline to use any OpenAI-compatible API provider, including Azure OpenAI, self-hosted inference servers, and other third-party services.
## What are Custom Providers?
Custom providers include any API that implements the OpenAI API format:
- **Azure OpenAI Service**: Microsoft's managed OpenAI models
- **vLLM**: Self-hosted inference server
- **Ollama**: Local model runner
- **Text Generation Inference (TGI)**: Hugging Face's inference server
- **LocalAI**: Local OpenAI API replacement
- **Other OpenAI-compatible APIs**: Any custom implementation
## Configuration Format
Configure custom providers through your remote configuration JSON using the `providerSettings.OpenAiCompatible` section:
```json
{
"providerSettings": {
"OpenAiCompatible": {
"models": [
{
"id": "gpt-4-turbo",
"name": "GPT-4 Turbo"
}
],
"openAiBaseUrl": "https://your-api.company.com/v1"
}
}
}
```
## Configuration Fields
| Field | Type | Description | Required |
|-------|------|-------------|----------|
| `models` | Array | List of model configurations | Yes |
| `openAiBaseUrl` | String | API endpoint base URL | Yes |
| `openAiApiKey` | String | API key for authentication | No |
| `openAiModelId` | String | Default model identifier | No |
### Azure OpenAI Specific Fields
For Azure OpenAI, additional fields are available:
| Field | Type | Description |
|-------|------|-------------|
| `azureApiVersion` | String | Azure API version (e.g., `2024-02-15-preview`) |
## Example Configurations
### Azure OpenAI
```json
{
"providerSettings": {
"OpenAiCompatible": {
"models": [
{
"id": "gpt-4-turbo",
"name": "GPT-4 Turbo"
}
],
"openAiBaseUrl": "https://your-resource.openai.azure.com/openai/deployments/gpt-4-turbo",
"openAiApiKey": "your-azure-api-key",
"azureApiVersion": "2024-02-15-preview"
}
}
}
```
### Self-Hosted vLLM
```json
{
"providerSettings": {
"OpenAiCompatible": {
"models": [
{
"id": "meta-llama/Llama-2-70b-chat-hf",
"name": "Llama 2 70B"
}
],
"openAiBaseUrl": "http://vllm.company.com:8000/v1"
}
}
}
```
### Local Ollama
```json
{
"providerSettings": {
"OpenAiCompatible": {
"models": [
{
"id": "codellama",
"name": "Code Llama"
}
],
"openAiBaseUrl": "http://localhost:11434/v1"
}
}
}
```
### Text Generation Inference (TGI)
```json
{
"providerSettings": {
"OpenAiCompatible": {
"models": [
{
"id": "mistralai/Mistral-7B-Instruct-v0.2",
"name": "Mistral 7B Instruct"
}
],
"openAiBaseUrl": "http://tgi.company.com:8080/v1",
"openAiApiKey": "your-tgi-api-key"
}
}
}
```
### LocalAI
```json
{
"providerSettings": {
"OpenAiCompatible": {
"models": [
{
"id": "gpt-3.5-turbo",
"name": "Local GPT-3.5"
}
],
"openAiBaseUrl": "http://localhost:8080/v1"
}
}
}
```
### Internal Network (No Auth)
```json
{
"providerSettings": {
"OpenAiCompatible": {
"models": [
{
"id": "custom-model",
"name": "Custom Model"
}
],
"openAiBaseUrl": "http://internal.api:8000/v1"
}
}
}
```
## Model Configuration
Each model requires basic information:
```json
{
"id": "model-identifier",
"name": "Display Name",
"info": {
"maxTokens": 4096,
"contextWindow": 128000,
"supportsImages": true,
"supportsPromptCache": false
}
}
```
## Prerequisites
Before configuring a custom provider, you need:
1. **API Endpoint**: URL of your OpenAI-compatible API
2. **API Key** (if required): Authentication credentials
3. **Model IDs**: Names of available models
4. **Network Access**: Connectivity from where Cline is being used
## Troubleshooting
**Connection Errors**
Verify the endpoint is accessible:
```bash
curl https://your-api.company.com/v1/models
```
**Authentication Errors**
Test authentication with your API key:
```bash
curl -H "Authorization: Bearer your-api-key" \
https://your-api.company.com/v1/models
```
**Model Not Found**
Ensure the model ID in your configuration matches what the API expects. Check available models:
```bash
curl -H "Authorization: Bearer your-api-key" \
https://your-api.company.com/v1/models
```
**Timeout Issues**
If responses are slow:
- Check network latency
- Verify server has adequate resources
- Consider using faster models
## Provider Documentation
For setup and deployment of these services, see their official documentation:
<CardGroup cols={2}>
<Card title="Azure OpenAI" icon="microsoft" href="https://learn.microsoft.com/en-us/azure/ai-services/openai/">
Microsoft's managed OpenAI service
</Card>
<Card title="vLLM" icon="server" href="https://docs.vllm.ai/">
High-performance inference engine
</Card>
<Card title="Ollama" icon="download" href="https://ollama.ai/">
Run models locally
</Card>
<Card title="Text Generation Inference" icon="code" href="https://huggingface.co/docs/text-generation-inference/">
Hugging Face inference server
</Card>
</CardGroup>
@@ -0,0 +1,185 @@
---
title: "Google Vertex AI Configuration"
sidebarTitle: "Google Vertex"
description: "Configure Google Vertex AI for your Cline deployment"
---
<Info>
**Configuration Path: Self-Hosted**
This guide covers Vertex AI configuration for self-hosted deployments. For simple web-based setup, see [Google Vertex SaaS Configuration](/enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration).
</Info>
Configure Cline to use Google Vertex AI for enterprise access to Gemini and other Google AI models through Google Cloud Platform.
## Configuration Format
Configure Vertex AI through your remote configuration JSON using the `providerSettings.Vertex` section:
```json
{
"providerSettings": {
"Vertex": {
"models": [
{
"id": "claude-3-5-sonnet-v2@20241022",
"name": "Claude 3.5 Sonnet"
}
],
"vertexProjectId": "my-project-id",
"vertexRegion": "us-central1"
}
}
}
```
## Configuration Fields
| Field | Type | Description | Required |
|-------|------|-------------|----------|
| `models` | Array | List of model configurations | Yes |
| `vertexProjectId` | String | Google Cloud project ID | Yes |
| `vertexRegion` | String | GCP region (e.g., `us-central1`) | Yes |
### Model Configuration
Each model in the `models` array requires:
```json
{
"id": "claude-3-5-sonnet-v2@20241022",
"name": "Claude 3.5 Sonnet",
"info": {
"maxTokens": 8192,
"contextWindow": 200000,
"supportsImages": true,
"supportsPromptCache": true
}
}
```
## Common Model IDs
| Model ID | Description | Context Window |
|----------|-------------|----------------|
| `claude-3-5-sonnet-v2@20241022` | Claude 3.5 Sonnet | 200K tokens |
| `claude-3-5-haiku@20241022` | Claude 3.5 Haiku | 200K tokens |
| `claude-3-opus@20240229` | Claude 3 Opus | 200K tokens |
| `gemini-2.0-flash-exp` | Gemini Flash (experimental) | 1M tokens |
| `gemini-1.5-pro-002` | Gemini Pro | 2M tokens |
| `gemini-1.5-flash-002` | Gemini Flash | 1M tokens |
<Note>
Model availability varies by region. See [Vertex AI documentation](https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models) for region-specific model availability.
</Note>
## Example Configurations
### Basic Configuration
```json
{
"providerSettings": {
"Vertex": {
"models": [
{
"id": "claude-3-5-sonnet-v2@20241022",
"name": "Claude 3.5 Sonnet"
}
],
"vertexProjectId": "my-company-prod",
"vertexRegion": "us-central1"
}
}
}
```
### Multiple Models
```json
{
"providerSettings": {
"Vertex": {
"models": [
{
"id": "claude-3-5-sonnet-v2@20241022",
"name": "Claude 3.5 Sonnet"
},
{
"id": "gemini-1.5-pro-002",
"name": "Gemini Pro"
}
],
"vertexProjectId": "my-company-prod",
"vertexRegion": "us-central1"
}
}
}
```
### With Extended Thinking
```json
{
"providerSettings": {
"Vertex": {
"models": [
{
"id": "claude-3-5-sonnet-v2@20241022",
"name": "Claude 3.5 Sonnet",
"thinkingBudgetTokens": 1600
}
],
"vertexProjectId": "my-company-prod",
"vertexRegion": "us-central1"
}
}
}
```
## Prerequisites
Before configuring Cline to use Vertex AI, you need:
1. **Google Cloud Project** with Vertex AI API enabled
2. **Service Account** with Vertex AI User role (`roles/aiplatform.user`)
3. **Service Account Credentials** configured for authentication
4. **Model Access** verified in your project and region
<Tip>
For Google Cloud setup and authentication configuration, see the [Vertex AI documentation](https://cloud.google.com/vertex-ai/docs/generative-ai/start/quickstarts/quickstart-multimodal).
</Tip>
## Troubleshooting
**"Permission Denied" Errors**
Ensure your service account has the required Vertex AI permissions. See [Google Cloud IAM documentation](https://cloud.google.com/vertex-ai/docs/general/access-control) for permission requirements.
**"API Not Enabled" Errors**
Verify the Vertex AI API is enabled in your Google Cloud project.
**"Model Not Found" Errors**
Check that the model is available in your configured region and that your project has access to it.
## Related Resources
<CardGroup cols={2}>
<Card title="Vertex AI Docs" icon="book" href="https://cloud.google.com/vertex-ai/docs">
Complete Vertex AI documentation
</Card>
<Card title="Service Accounts" icon="key" href="https://cloud.google.com/iam/docs/service-accounts">
Service account best practices
</Card>
<Card title="Model Guide" icon="brain" href="https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models">
Available models and features
</Card>
<Card title="Pricing" icon="dollar-sign" href="https://cloud.google.com/vertex-ai/pricing">
Vertex AI pricing details
</Card>
</CardGroup>
@@ -0,0 +1,215 @@
---
title: "LiteLLM Configuration"
sidebarTitle: "LiteLLM"
description: "Configure LiteLLM proxy for your Cline deployment"
---
<Info>
**Configuration Path: Self-Hosted**
This guide covers LiteLLM configuration for self-hosted deployments. For web-based setup, see [LiteLLM SaaS Configuration](/enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration).
</Info>
Configure Cline to use an existing LiteLLM proxy for unified access to multiple AI models through a single API endpoint.
## What is LiteLLM?
[LiteLLM](https://github.com/BerriAI/litellm) is an open-source proxy that provides a unified OpenAI-compatible API for accessing 100+ AI models from different providers. Cline connects to your deployed LiteLLM instance.
<Note>
LiteLLM is a separate service you deploy and manage. This guide covers how to configure Cline to connect to an existing LiteLLM deployment.
</Note>
## Configuration Format
Configure LiteLLM through your remote configuration JSON using the `providerSettings.OpenAiCompatible` section:
```json
{
"providerSettings": {
"OpenAiCompatible": {
"models": [
{
"id": "gpt-4-turbo",
"name": "GPT-4 Turbo"
}
],
"openAiBaseUrl": "https://litellm.yourcompany.com/v1"
}
}
}
```
## Configuration Fields
| Field | Type | Description | Required |
|-------|------|-------------|----------|
| `models` | Array | List of model configurations | Yes |
| `openAiBaseUrl` | String | LiteLLM proxy endpoint URL | Yes |
| `openAiApiKey` | String | API key for authentication | No |
### Model Configuration
Each model in the `models` array requires:
```json
{
"id": "gpt-4-turbo",
"name": "GPT-4 Turbo",
"info": {
"maxTokens": 4096,
"contextWindow": 128000,
"supportsImages": true
}
}
```
<Note>
Model IDs must match the model names configured in your LiteLLM proxy deployment.
</Note>
## Example Configurations
### Basic Configuration
```json
{
"providerSettings": {
"OpenAiCompatible": {
"models": [
{
"id": "gpt-4-turbo",
"name": "GPT-4 Turbo"
}
],
"openAiBaseUrl": "https://litellm.company.com/v1"
}
}
}
```
### With Authentication
```json
{
"providerSettings": {
"OpenAiCompatible": {
"models": [
{
"id": "gpt-4-turbo",
"name": "GPT-4 Turbo"
}
],
"openAiBaseUrl": "https://litellm.company.com/v1",
"openAiApiKey": "sk-your-litellm-key"
}
}
}
```
### Multiple Models
```json
{
"providerSettings": {
"OpenAiCompatible": {
"models": [
{
"id": "gpt-4-turbo",
"name": "GPT-4 Turbo"
},
{
"id": "claude-3-5-sonnet",
"name": "Claude 3.5 Sonnet"
},
{
"id": "gemini-pro",
"name": "Gemini Pro"
}
],
"openAiBaseUrl": "https://litellm.company.com/v1",
"openAiApiKey": "sk-your-litellm-key"
}
}
}
```
### Internal Network (No Auth)
```json
{
"providerSettings": {
"OpenAiCompatible": {
"models": [
{
"id": "gpt-4-turbo",
"name": "GPT-4 Turbo"
}
],
"openAiBaseUrl": "http://litellm.internal:4000/v1"
}
}
}
```
## Prerequisites
Before configuring Cline to use LiteLLM, you need:
1. **LiteLLM Proxy** deployed and accessible
2. **LiteLLM Configuration** with desired models enabled
3. **API Key** (if authentication is enabled)
4. **Network Access** from where Cline is being used
<Tip>
For LiteLLM deployment and configuration, see the [LiteLLM documentation](https://docs.litellm.ai/docs/proxy/quick_start).
</Tip>
## Troubleshooting
**Connection Errors**
Verify the LiteLLM proxy is running and accessible:
```bash
curl https://litellm.yourcompany.com/health
```
**Authentication Errors**
Check your API key is valid:
```bash
curl -H "Authorization: Bearer sk-your-key" \
https://litellm.yourcompany.com/v1/models
```
**Model Not Found**
Verify the model is configured in your LiteLLM deployment. Model IDs in Cline's config must match the model names in LiteLLM's configuration.
## Benefits of Using LiteLLM
- **Multi-Provider Access**: Connect to multiple AI providers through one endpoint
- **Load Balancing**: Distribute requests across providers automatically
- **Fallback Support**: Automatic retry with different models on failure
- **Cost Tracking**: Monitor usage and costs across all models
- **Rate Limiting**: Control usage at the proxy level
## Related Resources
<CardGroup cols={2}>
<Card title="LiteLLM Docs" icon="book" href="https://docs.litellm.ai/">
Complete LiteLLM documentation
</Card>
<Card title="LiteLLM GitHub" icon="github" href="https://github.com/BerriAI/litellm">
Source code and deployment examples
</Card>
<Card title="Proxy Setup" icon="server" href="https://docs.litellm.ai/docs/proxy/quick_start">
LiteLLM proxy deployment guide
</Card>
<Card title="Supported Providers" icon="list" href="https://docs.litellm.ai/docs/providers">
List of supported AI providers
</Card>
</CardGroup>
@@ -0,0 +1,144 @@
---
title: "AI Provider Configuration"
sidebarTitle: "Overview"
description: "Configure AI provider settings for your Cline deployment"
---
<Info>
**Configuration Path: Self-Hosted**
This section covers provider configuration for self-hosted deployments. For web-based configuration through app.cline.bot, see [SaaS Provider Configuration](/enterprise-solutions/configuration/remote-configuration/overview).
</Info>
Configure which AI providers your team can use and manage provider credentials centrally. Cline supports major AI providers with enterprise-grade authentication options.
## Supported Providers
<CardGroup cols={2}>
<Card title="AWS Bedrock" icon="aws" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/aws-bedrock">
Amazon's managed service for Claude and other foundation models
</Card>
<Card title="Google Vertex AI" icon="google" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/google-vertex">
Google Cloud's AI platform with Gemini and PaLM models
</Card>
<Card title="LiteLLM" icon="zap" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/litellm">
Universal proxy for accessing 100+ AI models through a unified API
</Card>
<Card title="Custom Providers" icon="plug" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/custom">
OpenAI-compatible APIs and self-hosted models
</Card>
</CardGroup>
## What is Provider Configuration?
Provider configuration in Cline allows administrators to:
1. **Manage Credentials Centrally**: Store API keys and authentication details in one place
2. **Control Model Access**: Specify which models teams can use
3. **Enforce Provider Usage**: Direct all team members to approved providers
## How It Works
Provider settings are configured through your remote configuration JSON file:
```json
{
"providerSettings": {
"provider": "bedrock",
"bedrockRegion": "us-east-1",
"bedrockServiceRole": "arn:aws:iam::..."
}
}
```
When configured, these settings:
- Apply to all team members automatically
- Override individual user settings
- Ensure consistent provider usage across the team
## Configuration Options
### Provider Selection
Choose from supported providers:
- **bedrock**: Use AWS Bedrock
- **vertex**: Use Google Vertex AI
- **openai**: Use OpenAI API
- **azure**: Use Azure OpenAI
- **litellm**: Use a LiteLLM proxy
### Authentication
Each provider supports different authentication methods:
**AWS Bedrock:**
- IAM roles with cross-account access
- Access keys (not recommended for production)
**Google Vertex AI:**
- Service account JSON keys
- Workload Identity (for GKE deployments)
**OpenAI/Azure:**
- API keys
**LiteLLM:**
- Endpoint URL + API key
## Example Configurations
### AWS Bedrock with IAM Role
```json
{
"providerSettings": {
"provider": "bedrock",
"bedrockRegion": "us-east-1",
"bedrockServiceRole": "arn:aws:iam::123456789012:role/ClineBedrockRole"
}
}
```
### Google Vertex AI
```json
{
"providerSettings": {
"provider": "vertex",
"vertexProject": "my-project-id",
"vertexRegion": "us-central1"
}
}
```
### LiteLLM Proxy
```json
{
"providerSettings": {
"provider": "litellm",
"litellmBaseUrl": "https://litellm.company.com",
"litellmApiKey": "sk-..."
}
}
```
## Next Steps
<CardGroup cols={2}>
<Card title="Configure AWS Bedrock" icon="aws" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/aws-bedrock">
Set up AWS Bedrock integration
</Card>
<Card title="Configure Google Vertex" icon="google" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/google-vertex">
Set up Google Vertex AI integration
</Card>
<Card title="Configure LiteLLM" icon="zap" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/litellm">
Set up LiteLLM proxy integration
</Card>
<Card title="Configure Custom Provider" icon="plug" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/custom">
Set up custom OpenAI-compatible provider
</Card>
</CardGroup>
@@ -0,0 +1,239 @@
---
title: "Rules"
sidebarTitle: "Rules"
description: "Custom instruction files that guide Cline's behavior in your enterprise deployment"
---
Rules are custom instruction files that provide Cline with guidelines about your coding preferences, standards, and best practices. These instructions get added to Cline's context when working on tasks.
## What are Rules?
Rules are simple markdown files stored in a `.clinerules/` directory that contain your team's conventions, preferences, and guidelines. They help Cline understand your:
- Coding style and conventions
- Preferred libraries and frameworks
- Architectural patterns
- Testing strategies
- Documentation standards
- Communication preferences
<Tip>
Rules are just `.md` files - no complex configuration needed!
</Tip>
## Quick Example
Here's a simple rule file that guides TypeScript development:
```markdown
# TypeScript Conventions
## Code Style
- Use 2-space indentation
- Prefer `const` over `let`
- Always use explicit return types for functions
- Use named exports instead of default exports
## Testing
- Write unit tests for all utility functions
- Use Vitest as the testing framework
- Aim for 80%+ code coverage
## Dependencies
- Prefer native TypeScript features over external libraries
- Use Zod for runtime type validation
- Use date-fns for date manipulation
```
## Creating Rules
<Tabs>
<Tab title="Using /newrule Command">
The easiest way to create a rule is with the `/newrule` command:
1. During a conversation with Cline, type `/newrule`
2. Cline will analyze your conversation and preferences
3. It creates an appropriately named `.md` file in `.clinerules/`
**Example:**
```
/newrule
Based on our conversation, create a rule for React component structure
```
</Tab>
<Tab title="Manual Creation">
You can also create rule files manually:
1. Create a `.clinerules/` directory in your repository root
2. Add markdown files with your guidelines
3. Use descriptive names like `react-patterns.md` or `api-conventions.md`
**File structure:**
```
your-repo/
├── .clinerules/
│ ├── typescript-style.md
│ ├── testing-standards.md
│ └── code-review-checklist.md
└── src/
```
</Tab>
</Tabs>
## Global vs Workspace Rules
<CardGroup cols={2}>
<Card title="Workspace Rules" icon="folder">
**Location:** `.clinerules/` in your repository
**Scope:** Specific to that project
**Use for:** Project-specific conventions and patterns
</Card>
<Card title="Global Rules" icon="globe">
**Location:** `Documents/Cline/` directory
**Scope:** All your projects
**Use for:** Personal preferences that apply everywhere
</Card>
</CardGroup>
## Managing Rules
### Toggling Rules
You can enable or disable individual rule files:
1. Click the rules icon in Cline's interface
2. Toggle rules on/off as needed
3. Changes apply immediately to new tasks
<Note>
Disabling a rule removes it from Cline's context, but keeps the file intact. You can re-enable it anytime.
</Note>
### Enterprise Remote Rules
<Info>
Enterprise deployments can configure **remote global rules** that apply to all team members. These are managed through your infrastructure configuration and cannot be toggled off by individual developers.
See [Self-Hosted Configuration](/enterprise-solutions/configuration/infrastructure-configuration/overview) for details on remote rules.
</Info>
## Compatible Formats
Cline also respects rules from other AI coding tools:
| File/Directory | Tool | Location |
|----------------|------|----------|
| `.cursorrules` | Cursor | Workspace root (single file) |
| `.cursor/rules/` | Cursor | Workspace directory (`.mdc` files) |
| `.windsurfrules` | Windsurf | Workspace root (single file) |
| `AGENTS.md` | Various | Workspace root + recursive search |
<Note>
**AGENTS.md behavior:** Cline only searches for nested `AGENTS.md` files recursively if a top-level `AGENTS.md` exists in your workspace root. If found, all `AGENTS.md` files are combined with their relative paths as headers.
</Note>
These files work the same way as `.clinerules/` files and can be toggled on/off independently.
## Best Practices
<AccordionGroup>
<Accordion title="Keep Rules Focused" icon="bullseye">
Each rule file should focus on one topic:
- ✅ `typescript-conventions.md`
- ✅ `react-component-structure.md`
- ❌ `everything-about-our-codebase.md`
</Accordion>
<Accordion title="Be Specific, Not Generic" icon="crosshairs">
Base rules on actual team preferences, not assumptions:
- ✅ "We use React Query for server state management"
- ❌ "Use best practices for state management"
</Accordion>
<Accordion title="Update Rules as Projects Evolve" icon="rotate">
Review and update rules periodically:
- When adopting new technologies
- After major architectural changes
- When team conventions evolve
</Accordion>
<Accordion title="Don't Overdo It" icon="gauge-simple-high">
Too many rules can overwhelm Cline's context:
- Start with 3-5 essential rules
- Add more only when truly needed
- Remove outdated rules promptly
</Accordion>
</AccordionGroup>
## Example Rule Files
<AccordionGroup>
<Accordion title="API Design Standards" icon="code">
```markdown
# API Design Standards
## REST Conventions
- Use plural nouns for endpoints (`/users`, not `/user`)
- Use HTTP methods semantically (GET, POST, PUT, DELETE)
- Return appropriate status codes
## Response Format
\`\`\`typescript
{
data: T,
error?: string,
metadata?: {
page: number,
total: number
}
}
\`\`\`
## Error Handling
- Always return error messages in `error` field
- Use 4xx for client errors, 5xx for server errors
- Include request ID in error responses
```
</Accordion>
<Accordion title="Testing Requirements" icon="vial">
```markdown
# Testing Requirements
## Test Organization
- Place tests next to source files (`Button.test.tsx`)
- Use `describe` blocks to group related tests
- Write descriptive test names
## Coverage Requirements
- Unit tests for all utility functions
- Integration tests for API endpoints
- E2E tests for critical user flows
- Minimum 80% coverage for new code
## Mocking Strategy
- Mock external API calls
- Use test fixtures for complex data
- Prefer dependency injection for testability
```
</Accordion>
</AccordionGroup>
## Next Steps
<CardGroup cols={2}>
<Card title="Workflows" icon="diagram-project" href="/enterprise-solutions/configuration/infrastructure-configuration/workflows">
Combine rules with automated workflows
</Card>
<Card title="Remote Configuration" icon="cloud" href="/enterprise-solutions/configuration/remote-configuration/overview">
Deploy global rules for your team
</Card>
</CardGroup>
@@ -0,0 +1,324 @@
---
title: "Workflows"
sidebarTitle: "Workflows"
description: "Reusable instruction sets that can be invoked on-demand via slash commands"
---
Workflows are markdown files containing reusable instructions that you can invoke on-demand using slash commands. Think of them as "rules you can call when needed" rather than always-active guidelines.
## What are Workflows?
Workflows are similar to [Rules](/enterprise-solutions/configuration/infrastructure-configuration/rules), but with one key difference:
<CardGroup cols={2}>
<Card title="Rules" icon="book">
**Always Active**
Automatically applied to every task when toggled on
Example: Coding standards, style guides
</Card>
<Card title="Workflows" icon="diagram-project">
**On-Demand**
Invoked only when you use the slash command
Example: Deployment checklists, review processes
</Card>
</CardGroup>
<Tip>
Workflows are just markdown files, no complex configuration needed!
</Tip>
## Quick Example
Here's a simple deployment workflow:
**File:** `.clinerules/workflows/deploy.md`
```markdown
# Deployment Workflow
Before deploying to production, ensure:
## Pre-Deployment Checklist
1. All tests passing (unit, integration, e2e)
2. Code review approved by 2+ engineers
3. Staging environment tested successfully
4. Database migrations reviewed
5. Rollback plan documented
## Deployment Steps
1. Create deployment branch from main
2. Run final test suite
3. Deploy to production
4. Monitor error rates for 30 minutes
5. Verify key user flows
## Post-Deployment
1. Update deployment log
2. Notify team in #deployments channel
3. Monitor metrics for 24 hours
```
**Usage:**
```
/deploy
I'm ready to deploy the new authentication feature
```
When invoked, Cline adds the workflow instructions to its context for that specific task.
## Creating Workflows
<Tabs>
<Tab title="Manual Creation">
Create workflow files in the `.clinerules/workflows/` directory:
1. Create `.clinerules/workflows/` in your repository root
2. Add markdown files with your workflow instructions
3. Use descriptive names matching your slash command
**File structure:**
```
your-repo/
├── .clinerules/
│ └── workflows/
│ ├── deploy.md
│ ├── code-review.md
│ └── bug-triage.md
└── src/
```
</Tab>
<Tab title="Slash Command">
You can also create workflows during a conversation:
1. Have a conversation about a process you want to codify
2. Type `/newrule` and specify it should be a workflow
3. Cline creates the workflow file in `.clinerules/workflows/`
<Note>
The `/newrule` command can create both rules and workflows - just specify your intent clearly.
</Note>
</Tab>
</Tabs>
## Using Workflows
### Invoking Workflows
Simply type `/` followed by the workflow filename (without `.md`):
```
/deploy
/code-review
/bug-triage
```
The workflow instructions are added to Cline's context for the current task only.
### Workflow Naming
- Use lowercase with hyphens: `deploy.md`, `code-review.md`
- Keep names short and memorable
- Name should indicate the workflow's purpose
<Warning>
Workflow filenames become slash commands, so choose names that are easy to type and remember.
</Warning>
## Global vs Workspace Workflows
<CardGroup cols={2}>
<Card title="Workspace Workflows" icon="folder">
**Location:** `.clinerules/workflows/` in your repository
**Scope:** Specific to that project
**Use for:** Project-specific processes and checklists
</Card>
<Card title="Global Workflows" icon="globe">
**Location:** `Documents/Cline/Workflows/` directory
**Scope:** All your projects
**Use for:** Personal workflows that apply everywhere
</Card>
</CardGroup>
<Info>
**Precedence:** Local workflows override global workflows if they have the same name.
</Info>
## Managing Workflows
### Toggling Workflows
You can enable or disable workflows:
1. Click the rules icon in Cline's interface
2. Switch to the "Workflows" tab
3. Toggle workflows on/off as needed
<Note>
Disabling a workflow prevents it from being invoked, but keeps the file intact. The slash command won't work until you re-enable it.
</Note>
### Enterprise Remote Workflows
<Info>
Enterprise deployments can configure **remote global workflows** that are available to all team members. These are managed through your infrastructure configuration.
See [Self-Hosted Configuration](/enterprise-solutions/configuration/infrastructure-configuration/overview) for details on remote workflows.
</Info>
## Example Workflows
<AccordionGroup>
<Accordion title="Code Review Workflow" icon="code-review">
```markdown
# Code Review Workflow
## Pre-Review Checklist
- [ ] Code follows project style guide
- [ ] All tests pass locally
- [ ] No console.log or debugging code
- [ ] Comments explain "why" not "what"
- [ ] PR description is clear and complete
## Review Focus Areas
1. **Architecture**: Does this fit our existing patterns?
2. **Security**: Any potential vulnerabilities?
3. **Performance**: Any obvious bottlenecks?
4. **Testing**: Are edge cases covered?
5. **Documentation**: Is it clear how to use new features?
## Review Response
- Address all feedback within 24 hours
- Mark conversations as resolved when addressed
- Re-request review after major changes
```
</Accordion>
<Accordion title="Bug Triage Workflow" icon="bug">
```markdown
# Bug Triage Workflow
## Information Gathering
1. Reproduce the bug in local environment
2. Identify affected versions/environments
3. Check if similar issues exist
4. Gather error logs and stack traces
## Priority Assessment
**P0 (Critical)**: Production down, data loss, security breach
**P1 (High)**: Major feature broken, significant user impact
**P2 (Medium)**: Minor feature broken, workaround available
**P3 (Low)**: Cosmetic issue, minimal impact
## Create Ticket
- Use template: "Bug Report"
- Add reproduction steps
- Include screenshots/videos if applicable
- Tag with affected component
- Assign priority label
## Next Steps
- P0/P1: Immediate fix required
- P2: Schedule for current sprint
- P3: Add to backlog
```
</Accordion>
<Accordion title="Feature Planning Workflow" icon="lightbulb">
```markdown
# Feature Planning Workflow
## Requirements Gathering
1. Define the user problem we're solving
2. List success criteria (measurable)
3. Identify edge cases and constraints
4. Document technical dependencies
## Design Considerations
1. How does this fit existing architecture?
2. What data models are needed?
3. What API changes are required?
4. How will this impact performance?
## Implementation Plan
1. Break into smaller, shippable pieces
2. Identify which pieces can be done in parallel
3. Note any feature flags needed
4. Plan for backwards compatibility
## Testing Strategy
1. What unit tests are needed?
2. What integration tests are needed?
3. How will we test edge cases?
4. What manual testing is required?
```
</Accordion>
</AccordionGroup>
## Best Practices
<AccordionGroup>
<Accordion title="Keep Workflows Action-Oriented" icon="list-check">
Workflows should contain **actionable steps**, not general advice:
- ✅ "Run `npm test` and verify all tests pass"
- ❌ "Make sure testing is done properly"
</Accordion>
<Accordion title="Use Checklists" icon="square-check">
Format workflows as checklists when possible:
- Easy to follow step-by-step
- Clear progress tracking
- Reduces missed steps
</Accordion>
<Accordion title="Include Context" icon="circle-info">
Add **why** behind each step:
```markdown
1. Check staging environment first
(Catching issues in staging prevents production incidents)
```
</Accordion>
<Accordion title="Version as Code" icon="code-branch">
Workflows live in your repository:
- Track changes in git
- Review updates in PRs
- Maintain history of process evolution
</Accordion>
</AccordionGroup>
## Workflows vs Rules: When to Use Each
| Use Rules When | Use Workflows When |
|----------------|-------------------|
| Guidance should apply to every task | Process is invoked occasionally |
| Standards that rarely change | Checklist for specific scenarios |
| Always-on coding conventions | On-demand deployment processes |
| General coding style | Specific review procedures |
**Example:**
- **Rule**: "Use TypeScript strict mode and explicit return types"
- **Workflow**: "Follow these 10 steps when deploying to production"
## Next Steps
<CardGroup cols={2}>
<Card title="Rules" icon="book" href="/enterprise-solutions/configuration/infrastructure-configuration/rules">
Learn about always-active rules
</Card>
<Card title="Remote Configuration" icon="cloud" href="/enterprise-solutions/configuration/remote-configuration/overview">
Deploy global workflows for your team
</Card>
</CardGroup>
@@ -0,0 +1,97 @@
---
title: "Configuration Overview"
sidebarTitle: "Overview"
description: "Understanding enterprise configuration options for inference providers and system settings"
---
Cline offers two distinct approaches to configure inference providers and system settings for your organization. Understanding the difference between these approaches will help you choose the right configuration method for your needs.
## Configuration Types
<Info>
**Need help choosing?** See the [Deployment Guide](/enterprise-solutions/configuration/choosing-your-deployment) for a detailed comparison and decision tree.
</Info>
<CardGroup cols={2}>
<Card title="SaaS Provider Configuration" icon="cloud" href="/enterprise-solutions/configuration/remote-configuration/overview">
**Simple cloud-based setup**
Configure inference providers through the Cline [admin console](https://app.cline.bot/dashboard). Ideal for quick organizational deployment with minimal infrastructure requirements.
</Card>
<Card title="Self-Hosted Configuration" icon="server" href="/enterprise-solutions/configuration/infrastructure-configuration/overview">
**Advanced enterprise setup**
Deep infrastructure integration with VPC endpoints, multi-account support, compliance features, and custom workflows on your own infrastructure.
</Card>
</CardGroup>
## Choosing the Right Configuration
### Use SaaS Configuration When:
- **Quick Setup**: You need to get your team up and running quickly
- **Centralized Management**: You want simple, cloud-based provider management
- **Standard Requirements**: Your organization has typical security and compliance needs
- **Small to Medium Teams**: You're managing dozens to hundreds of users
### Use Self-Hosted Configuration When:
- **Enterprise Security**: You need advanced security features and compliance controls
- **Complex Infrastructure**: You have existing AWS/GCP infrastructure to integrate with
- **Custom Workflows**: You need custom rules, workflows, and automation
- **Large Organizations**: You're managing hundreds to thousands of users
- **Air-Gapped Environments**: You need on-premises or restricted network deployment
## Configuration Comparison
| Feature | SaaS Configuration | Self-Hosted Configuration |
|---------|-------------------|---------------------------|
| **Setup Complexity** | Simple | Advanced |
| **Deployment Time** | Minutes | Days to Weeks |
| **Infrastructure Required** | None | AWS/GCP/Azure |
| **Compliance Features** | Basic | Advanced |
| **Custom Rules** | No | Yes |
| **Multi-Account Support** | No | Yes |
| **VPC Integration** | No | Yes |
| **Cost** | Lower | Higher |
## Getting Started
<Steps>
<Step title="Evaluate Your Requirements">
Review your organization's security, compliance, and infrastructure requirements to determine which configuration approach fits your needs.
</Step>
<Step title="Choose Your Path">
Select either SaaS Configuration for simple setup or Self-Hosted Configuration for advanced enterprise features. Use the [Deployment Guide](/enterprise-solutions/configuration/choosing-your-deployment) if you need help deciding.
</Step>
<Step title="Follow Configuration Guide">
Complete the setup process using the detailed guides for your chosen configuration type.
</Step>
<Step title="Onboard Team Members">
Once configured, team members can connect using the provider-specific member guides.
</Step>
</Steps>
---
## Available Providers
Both configuration approaches support the same core inference providers:
<CardGroup cols={3}>
<Card title="AWS Bedrock" icon="aws">
Enterprise AI models with AWS infrastructure integration and security features.
</Card>
<Card title="LiteLLM" icon="layer-group">
Unified proxy for accessing 100+ AI models through a single interface.
</Card>
<Card title="Google Vertex AI" icon="google">
Google Cloud's AI platform with advanced ML capabilities and global infrastructure.
</Card>
</CardGroup>
The main difference lies in how these providers are configured and managed within your organization's infrastructure and security requirements.
@@ -4,7 +4,8 @@ sidebarTitle: "Configure AWS Bedrock (Admin)"
description: "This guide explains how administrators configure AWS Bedrock as the organization-wide LLM provider for Cline."
---
As an administrator, you can add AWS Bedrock as the organization-wide LLM provider for all Cline users. This centralized approach ensures consistent access to Amazon's AI models while maintaining your organization's security and compliance requirements through VPC endpoints, region controls, and prompt caching optimizations.
As an administrator, you can add AWS Bedrock as the organization-wide LLM provider for all Cline users through the hosted admin console. This centralized approach ensures consistent access to Amazon's AI models while maintaining your organization's security and compliance requirements through region controls and basic configuration options.
## Before You Begin
@@ -13,9 +14,6 @@ To get started with setting up AWS Bedrock as your organization's LLM provider,
**Administrator access to the Cline Admin console**
You need admin privileges to enforce provider settings across your organization. If you can navigate to **Settings → Cline Settings** in the admin console at [app.cline.bot](https://app.cline.bot), you have the right access level.
<Info>
**Quick Check**: Try accessing the settings page now. If you can see the provider configuration options, you're good to go.
</Info>
**AWS Bedrock account with the right permissions**
Your AWS account needs specific Bedrock permissions to work with Cline.
@@ -0,0 +1,112 @@
---
title: "Configure Google Vertex AI Provider (Admin)"
sidebarTitle: "Configure Google Vertex (Admin)"
description: "This guide explains how administrators configure Google Vertex AI as the organization-wide LLM provider for Cline."
---
As an administrator, you can add Google Vertex AI as the organization-wide LLM provider for all Cline users through the hosted admin console. This centralized approach ensures consistent access to Google's Gemini models while maintaining your organization's project boundaries and regional settings.
## Before You Begin
To get started with setting up Google Vertex AI as your organization's LLM provider, you'll need a few items in place.
**Administrator access to the Cline Admin console**
You need admin privileges to enforce provider settings across your organization. If you can navigate to **Settings → Cline Settings** in the admin console at [app.cline.bot](https://app.cline.bot), you have the right access level.
**Google Cloud Project with Vertex AI enabled**
You need a Google Cloud project with the Vertex AI API enabled and appropriate models accessible.
<Note>
If you haven't set up Google Cloud or Vertex AI yet, work with your cloud team to enable the Vertex AI API and ensure necessary quotas are configured.
</Note>
**Project configuration details**
You'll need your Google Cloud project ID and preferred region for Vertex AI model access.
<Tip>
Service accounts should have the minimum IAM permissions needed for Vertex AI access to follow security best practices.
</Tip>
## Configuration Steps
<Steps>
<Step title="Access Cline Settings">
Navigate to [app.cline.bot](https://app.cline.bot) and sign in with your administrator account. Go to **Settings → Cline Settings**.
<Info>
You should see the provider configuration options if you have the correct admin access level.
</Info>
</Step>
<Step title="Enable Remote Provider Configuration">
Toggle on **Enable settings** to reveal the remote provider configuration options. This allows you to enforce provider settings across your organization.
</Step>
<Step title="Select Google Vertex AI as the API Provider">
Open the **API Provider** dropdown menu and select **Google Vertex AI**. This will open the Vertex AI configuration panel where you'll configure all your organization-wide settings.
</Step>
<Step title="Configure Vertex AI Settings">
The configuration panel includes settings that control how Vertex AI works for your organization:
<AccordionGroup>
<Accordion title="Project ID (required)">
Enter your Google Cloud project ID where Vertex AI is enabled. This project will be used for all AI model requests from your organization members.
<Tip>
Use a dedicated project for AI workloads to better track usage and costs. Ensure the project has sufficient quotas for your team's expected usage.
</Tip>
</Accordion>
<Accordion title="Region (required)">
Select the Google Cloud region where your Vertex AI models should be accessed. Common options include `us-central1`, `us-east4`, or `europe-west4`.
[View Google Cloud Regions](https://cloud.google.com/docs/geography-and-regions)
<Note>
Choose a region close to your team's location for optimal performance. Some models may not be available in all regions.
</Note>
</Accordion>
</AccordionGroup>
</Step>
<Step title="Save Configuration">
After configuring your settings, close the provider configuration panel and click **Save** on the settings page to persist your changes.
Once saved, all organization members signed into the Cline extension will automatically use Google Vertex AI with your configured settings. They won't be able to select other providers or switch to their personal Cline accounts.
<Warning>
Members can't switch to personal Cline accounts or join other organizations once remote configuration is enabled. This ensures consistent provider usage across your team.
</Warning>
</Step>
</Steps>
## Verification
To verify the configuration:
1. Check that the provider shows as "Google Vertex AI" in the Enabled provider field
2. Confirm the settings persist after refreshing the page
3. Test with a member account to ensure they see only Vertex AI as a provider
4. Verify that Gemini models are available in the model dropdown
## Troubleshooting
**Members don't see the configured provider**
Ensure you clicked Save after closing the configuration panel. Verify the member account belongs to the correct organization and that your Google Cloud project has Vertex AI API enabled.
**Project access errors**
Verify the project ID is correct and that Vertex AI API is enabled. Check that the project has appropriate billing configured and hasn't exceeded quotas.
**Regional availability issues**
Confirm the selected region supports the Gemini models you want to use. Some newer models may only be available in specific regions.
**Configuration changes don't persist**
Make sure to click the Save button on the main settings page, not just close the configuration panel.
**Need to change project or region later**
You can update these settings at any time. Members will need to ensure their local Google Cloud credentials have access to the new project/region.
For further details, consult the [Google Cloud Vertex AI Documentation](https://cloud.google.com/vertex-ai/docs) and coordinate with your internal cloud team.
@@ -0,0 +1,177 @@
---
title: "Configure Google Vertex AI in VS Code (Members)"
sidebarTitle: "Configure Google Vertex (Member)"
description: "Guide for engineers connecting to their organization's Google Vertex AI setup through VS Code after admin setup"
---
As a team member, you can connect your local development environment to your organization's Google Vertex AI setup. This guide walks you through configuring your Google Cloud credentials in VS Code so you can start using Vertex AI models through your organization's configured project and regional settings. Your administrator has already configured the provider settings—you just need to add your credentials to get started.
## Before You Begin
To successfully connect to your organization's Google Vertex AI setup, you'll need a few things ready.
**Cline extension installed and configured**
The Cline extension must be installed in VS Code and you need to be signed into your organization account. If you haven't installed Cline yet, follow our [installation guide](/getting-started/installing-cline).
<Info>
**Quick Check**: Open the Cline panel in VS Code. If you see your organization name in the bottom left, you're signed in correctly.
</Info>
**Google Cloud credentials with Vertex AI access**
You need Google Cloud credentials that have permission to access Vertex AI in your organization's configured project and region.
<Note>
If you're unsure which method to use, check with your administrator or IT team about how your organization has configured Google Cloud access.
</Note>
## Configuration Steps
<Steps>
<Step title="Open Cline Settings">
Open VS Code and access the Cline settings panel using either of these methods:
- Click the settings icon (⚙️) in the Cline panel
- Click on the API Provider dropdown located directly below the chat area (it will display as `vertex_ai/gemini-pro` or similar)
</Step>
<Step title="Select Your Authentication Method">
Choose one of the following credential methods to authenticate with Google Vertex AI:
<AccordionGroup>
<Accordion title="Service Account Key">
Use a service account JSON key file for Vertex AI access.
[Learn more about Service Account Keys](https://cloud.google.com/iam/docs/service-accounts)
1. Select the **Service Account Key** authentication method
2. Upload or paste your service account JSON key content
3. The key should have `aiplatform.user` or similar Vertex AI permissions
4. These credentials are stored locally and used only by the VS Code extension
</Accordion>
<Accordion title="Google Cloud SDK">
Use the Google Cloud SDK installed on your machine with your authenticated account.
[Learn more about Google Cloud SDK](https://cloud.google.com/sdk/docs/install)
1. Select the **Google Cloud SDK** authentication method
2. Ensure you've authenticated with `gcloud auth login`
3. Verify your account has access to the organization's Vertex AI project
4. Cline will use your default Google Cloud credentials automatically
</Accordion>
<Accordion title="Application Default Credentials">
Use Google Cloud's application default credentials (ADC) chain.
1. Select the **Application Default Credentials** method
2. Ensure ADC is properly configured in your environment
3. This works well for environments where Google Cloud credentials are managed centrally
4. Cline will automatically detect credentials from your environment
</Accordion>
</AccordionGroup>
<Note>
The Google Cloud Project ID and Region are preconfigured by your administrator and do not need to be set in the extension.
</Note>
</Step>
<Step title="Verify Configuration">
After selecting your authentication method, the extension will display checkmarks for enabled features:
- ✓ Supports images (for Gemini Pro Vision and similar models)
- ✓ Supports multimodal inputs
- ✓ Supports function calling (for supported models)
The project ID and region settings will be locked (shown with a lock icon 🔒) as they're controlled by your administrator.
</Step>
<Step title="Test the Connection">
Send a test message in Cline to verify your credentials work correctly with the configured Vertex AI project and region.
<Tip>
**Testing Recommendation**
Try a simple test like "Hello" first to verify basic connectivity, then test multimodal capabilities if needed by sharing an image.
</Tip>
</Step>
</Steps>
## Model Usage
### Available Model Families
The models available through your organization's Vertex AI setup typically include:
**Gemini Models:**
- **Gemini Pro**: Advanced reasoning, code generation, and multimodal capabilities
- **Gemini Pro Vision**: Image understanding and visual question answering
- **Gemini Ultra**: Most capable model for complex reasoning tasks
**PaLM Models:**
- **PaLM 2 for Text**: Text generation and completion
- **PaLM 2 for Chat**: Conversational AI interactions
- **Codey**: Specialized for code generation and explanation
**Specialized Models:**
- **Text Embedding**: For semantic search and similarity tasks
- **Custom Models**: Your organization's fine-tuned variants (if available)
### Model Selection Strategy
Choose models based on your development needs:
- **General tasks**: Use Gemini Pro for most text and reasoning tasks
- **Visual content**: Use Gemini Pro Vision when working with images
- **Code-heavy work**: Use Codey models for programming tasks
- **Complex reasoning**: Use Gemini Ultra for sophisticated problem-solving
- **Embedding tasks**: Use Text Embedding models for semantic operations
### Multimodal Capabilities
Take advantage of Vertex AI's multimodal features:
- **Image Analysis**: Upload images directly in Cline for analysis
- **Visual Question Answering**: Ask questions about images
- **Code Screenshots**: Get explanations of code from screenshots
- **Document Processing**: Analyze charts, graphs, and visual data
## Troubleshooting
**Google Vertex AI not available as provider option**
Confirm you're signed into the correct Cline organization. Verify your administrator has saved the Vertex AI configuration and that you have the latest version of the Cline extension.
**Authentication errors ("Access Denied" or "Invalid Credentials")**
Verify your chosen credential method has the necessary IAM permissions to access Vertex AI in the configured project and region. Required permissions include `aiplatform.endpoints.predict` and `aiplatform.models.predict`.
**Project access errors**
Ask your administrator to confirm which Google Cloud project is configured for your organization. Ensure your Google Cloud credentials have access to that specific project.
**Regional access errors**
Verify your credentials have access to Vertex AI in the configured region. Some models may not be available in all regions, so confirm with your administrator about the selected region.
**Google Cloud SDK authentication issues**
Ensure Google Cloud SDK is properly installed and authenticated:
```bash
gcloud auth login
gcloud config set project YOUR_PROJECT_ID
gcloud auth application-default login
```
**Service account key errors**
Verify the service account key is valid and hasn't expired. Check that the service account has the proper Vertex AI permissions in your organization's project. Ensure the JSON key file is properly formatted and contains all required fields.
**Model access errors or "model not found"**
Some models may not be enabled in your organization's project or region. Contact your administrator if specific models are not available. Verify that your organization has enabled the models you're trying to use in the Google Cloud Console.
## Security Best Practices
When configuring your Google Cloud credentials, follow these security guidelines:
- Use service accounts with minimal required permissions for Vertex AI access
- Rotate service account keys regularly (every 90 days recommended)
- Never store credentials in code or version control
- Use Google Cloud SDK where possible for better credential management
- Consider using Workload Identity for containerized development environments
- Report any suspicious activity or unauthorized access attempts
Your organization administrator controls which models and regions are available. The extension will automatically display available models based on your project's configuration and regional availability.
For more information about Google Cloud authentication and Vertex AI permissions, refer to the [Google Cloud IAM Documentation](https://cloud.google.com/iam/docs) and coordinate with your organization's cloud administrator.
@@ -0,0 +1,120 @@
---
title: "Configure LiteLLM Provider (Admin)"
sidebarTitle: "Configure LiteLLM (Admin)"
description: "This guide explains how administrators configure LiteLLM as the organization-wide LLM provider for Cline."
---
As an administrator, you can add LiteLLM as the organization-wide LLM provider for all Cline users through the hosted admin console. This centralized approach provides unified access to multiple AI models through your LiteLLM proxy interface.
## Before You Begin
To get started with setting up LiteLLM as your organization's LLM provider, you'll need a few items in place.
**Administrator access to the Cline Admin console**
You need admin privileges to enforce provider settings across your organization. If you can navigate to **Settings → Cline Settings** in the admin console at [app.cline.bot](https://app.cline.bot), you have the right access level.
<Info>
**Quick Check**: Try accessing the settings page now. If you can see the provider configuration options, you're good to go.
</Info>
**LiteLLM proxy instance running**
You need a deployed LiteLLM proxy that your team can access. This can be self-hosted or managed through a cloud provider.
<Note>
If you haven't deployed LiteLLM yet, work with your infrastructure team to set up a LiteLLM proxy instance.
</Note>
**LiteLLM endpoint details**
You'll need the base URL of your LiteLLM proxy and optionally a master key if your deployment requires authentication.
<Tip>
Ensure your LiteLLM proxy is accessible from your team's development environments and has the models you want to make available configured.
</Tip>
## Configuration Steps
<Steps>
<Step title="Access Cline Settings">
Navigate to [app.cline.bot](https://app.cline.bot) and sign in with your administrator account. Go to **Settings → Cline Settings**.
<Info>
You should see the provider configuration options if you have the correct admin access level.
</Info>
</Step>
<Step title="Enable Remote Provider Configuration">
Toggle on **Enable settings** to reveal the remote provider configuration options. This allows you to enforce provider settings across your organization.
</Step>
<Step title="Select LiteLLM as the API Provider">
Open the **API Provider** dropdown menu and select **LiteLLM**. This will open the LiteLLM configuration panel where you'll configure all your organization-wide settings.
</Step>
<Step title="Configure LiteLLM Settings">
The configuration panel includes settings that control how LiteLLM works for your organization:
<AccordionGroup>
<Accordion title="Base URL (required)">
Enter your LiteLLM proxy endpoint URL. This should be the full URL where your LiteLLM proxy is accessible, such as `https://litellm.yourcompany.com` or `http://your-proxy:4000`.
<Tip>
Use HTTPS endpoints in production for security. Make sure the URL is accessible from your team's development environments.
</Tip>
</Accordion>
<Accordion title="Master Key (optional)">
If your LiteLLM proxy requires authentication, enter the master key here. This will be used to authenticate requests from all organization members.
<Note>
**Centralized API Key Management**: By configuring the Master Key at the organization level, you enable centralized API key management. Organization members won't need to manage their own individual API keys - access is fully managed through this centralized configuration.
</Note>
<Warning>
The master key provides full access to your LiteLLM proxy. Only enter this if your proxy requires authentication and you want centralized key management.
</Warning>
</Accordion>
</AccordionGroup>
</Step>
<Step title="Save Configuration">
After configuring your settings, close the provider configuration panel and click **Save** on the settings page to persist your changes.
Once saved, all organization members signed into the Cline extension will automatically use LiteLLM with your configured settings. They won't be able to select other providers or switch to their personal Cline accounts.
<Warning>
Members can't switch to personal Cline accounts or join other organizations once remote configuration is enabled. This ensures consistent provider usage across your team.
</Warning>
</Step>
</Steps>
## Verification
To verify the configuration:
1. Check that the provider shows as "LiteLLM" in the Enabled provider field
2. Confirm the settings persist after refreshing the page
3. Test with a member account to ensure they see only LiteLLM as a provider
4. Verify that the configured models are available in the model dropdown
## Troubleshooting
**Members don't see the configured provider**
Ensure you clicked Save after closing the configuration panel. Verify the member account belongs to the correct organization and that your LiteLLM proxy is accessible from their network.
**Connection errors to LiteLLM proxy**
Verify the Base URL is correct and accessible. Check that any firewalls or security groups allow access from your team's IP addresses or development environments.
**Authentication failures**
If using a master key, verify it's correctly entered and has proper permissions in your LiteLLM deployment. Check the LiteLLM proxy logs for authentication errors.
**Models not available**
Confirm the models are properly configured in your LiteLLM proxy deployment. The available models depend on how your LiteLLM proxy is configured.
**Configuration changes don't persist**
Make sure to click the Save button on the main settings page, not just close the configuration panel.
**Need to change endpoint or key later**
You can update these settings at any time. Changes take effect immediately for all organization members.
For further details about LiteLLM deployment and configuration, consult the [LiteLLM Documentation](https://docs.litellm.ai/) and coordinate with your infrastructure team.
@@ -0,0 +1,168 @@
---
title: "Configure LiteLLM in VS Code (Members)"
sidebarTitle: "Configure LiteLLM (Member)"
description: "Guide for engineers connecting to their organization's LiteLLM proxy through VS Code after admin setup"
---
As a team member, you can connect your local development environment to your organization's LiteLLM proxy setup. This guide walks you through configuring your connection in VS Code so you can start using multiple AI models through your organization's unified proxy interface. Your administrator has already configured the provider settings—you just need to add your credentials to get started.
## Before You Begin
To successfully connect to your organization's LiteLLM proxy, you'll need a few things ready.
**Cline extension installed and configured**
The Cline extension must be installed in VS Code and you need to be signed into your organization account. If you haven't installed Cline yet, follow our [installation guide](/getting-started/installing-cline).
<Info>
**Quick Check**: Open the Cline panel in VS Code. If you see your organization name in the bottom left, you're signed in correctly.
</Info>
**Access credentials for your organization's LiteLLM proxy**
You need credentials to access your organization's LiteLLM proxy. This might be an API key, or the proxy might be configured for open access within your network.
<Note>
If you're unsure about the credentials needed, check with your administrator or IT team about how to access your organization's LiteLLM proxy.
</Note>
## Configuration Steps
<Steps>
<Step title="Open Cline Settings">
Open VS Code and access the Cline settings panel using either of these methods:
- Click the settings icon (⚙️) in the Cline panel
- Click on the API Provider dropdown located directly below the chat area (it will display as `LiteLLM` or show a specific model name)
</Step>
<Step title="Configure LiteLLM Connection">
The LiteLLM configuration options depend on how your organization has set up the proxy:
<AccordionGroup>
<Accordion title="API Key Authentication">
If your organization requires API key authentication:
1. Select or confirm the **LiteLLM** provider is selected
2. Enter your assigned API key in the **API Key** field
3. The base URL should already be configured by your administrator
4. Click **Save** to store your credentials
<Tip>
API keys are stored locally in VS Code and are only used by the Cline extension.
</Tip>
</Accordion>
<Accordion title="Open Access (No Authentication)">
If your LiteLLM proxy is configured for open access within your network:
1. Select or confirm the **LiteLLM** provider is selected
2. Leave the API key field empty
3. The extension will connect directly to the configured proxy endpoint
4. No additional authentication is required
<Info>
Open access is common when the LiteLLM proxy is deployed within a secure network environment.
</Info>
</Accordion>
<Accordion title="Custom Configuration">
If your organization uses custom authentication or specific connection parameters:
1. Follow any custom instructions provided by your administrator
2. Contact your IT team if you encounter connection issues
3. Additional configuration may be needed outside of VS Code
<Note>
Custom configurations might require specific network settings or additional authentication steps.
</Note>
</Accordion>
</AccordionGroup>
</Step>
<Step title="Select Available Models">
Once connected, you'll see the models available through your organization's LiteLLM proxy:
- View available models in the model dropdown
- Models are determined by your administrator's proxy configuration
- You can switch between models for different types of tasks
- Some models may be restricted based on your access level
<Tip>
**Model Selection**
Choose models based on your task requirements:
- **Fast models** (like GPT-3.5-turbo) for quick responses
- **Powerful models** (like GPT-4) for complex reasoning
- **Specialized models** for code generation or specific domains
</Tip>
</Step>
<Step title="Test the Connection">
Send a test message in Cline to verify your connection works correctly with the LiteLLM proxy.
<Tip>
**Testing Recommendation**
Test the connection in plan mode first to verify everything works correctly before using it for actual development tasks.
</Tip>
</Step>
</Steps>
## Model Usage
### Available Model Categories
The models available through your LiteLLM proxy typically include:
**Text Generation Models:**
- OpenAI GPT-4, GPT-3.5-turbo variants
- Anthropic Claude 3 Sonnet, Haiku, Opus
- Open source models like Llama 2, Mistral
**Code-Specific Models:**
- OpenAI GPT-4 for code
- CodeLlama variants
- Specialized code completion models
**Multimodal Models:**
- GPT-4 Vision for image analysis
- Claude 3 models with vision capabilities
### Model Selection Strategy
Choose models based on your development needs:
- **Quick iterations**: Use faster, cost-effective models
- **Complex problems**: Use more powerful models
- **Code-heavy tasks**: Use code-specialized models
- **Visual content**: Use multimodal models when working with images
## Troubleshooting
**LiteLLM not available as provider option**
Confirm you're signed into the correct Cline organization. Verify your administrator has saved the LiteLLM configuration and that you have the latest version of the Cline extension.
**Connection errors or timeouts**
Verify your network can reach the LiteLLM proxy endpoint. Check with your IT team about firewall rules or VPN requirements. Ensure the proxy endpoint is accessible from your development environment.
**Authentication failures**
If using API key authentication, verify the key is correctly entered and hasn't expired. Contact your administrator to confirm your key is active and has the proper permissions.
**Models not loading or are limited**
The available models depend on your organization's LiteLLM configuration. Contact your administrator if you need access to specific models or if expected models aren't available.
**Slow response times**
Response times depend on the models being used and proxy load. Try switching to faster models for routine tasks. Contact your administrator if performance is consistently poor.
**Error messages from specific models**
Some models may be temporarily unavailable or have specific limitations. Try alternative models or contact your administrator if specific models are consistently failing.
## Security Best Practices
When working with your organization's LiteLLM proxy:
- Keep your API credentials secure and don't share them
- Use appropriate models for the sensitivity of your data
- Follow your organization's usage guidelines
- Report any suspicious activity or unauthorized access attempts
- Regularly update the Cline extension for security patches
Your organization administrator controls which models are available and usage policies. The extension will automatically display available models based on your proxy configuration and access level.
@@ -0,0 +1,102 @@
---
title: "SaaS Provider Configuration"
sidebarTitle: "Overview"
description: "Configure inference providers through the Cline hosted admin console for centralized organization management"
---
SaaS Provider Configuration allows administrators to centrally configure inference providers for their entire organization through the Cline hosted admin console. This approach ensures consistent provider access, security policies, and cost management across all team members without requiring individual developer setup or infrastructure deployment.
## How Remote Configuration Works
Remote configuration operates through Cline's hosted service at [app.cline.bot](https://app.cline.bot), where administrators can:
<CardGroup cols={2}>
<Card title="Centralized Setup" icon="gear">
Configure providers once for the entire organization through the web-based admin console.
</Card>
<Card title="Automatic Enforcement" icon="shield-check">
Team members automatically receive the configured provider settings when signed into their organization.
</Card>
<Card title="Simplified Onboarding" icon="user-plus">
New team members get instant access to inference providers without complex individual configuration.
</Card>
<Card title="Consistent Experience" icon="users">
Ensure all team members use the same models, regions, and settings organization-wide.
</Card>
</CardGroup>
## Supported Providers
Cline supports remote configuration for the following inference providers:
| Provider | Use Case | Configuration | Member Setup |
|----------|----------|---------------|--------------|
| **Cline** | Organizations using Cline's native provider with centralized API key management | API provider selection, model access | No individual API keys needed - fully managed by organization |
| **Amazon Bedrock** | Organizations using AWS infrastructure | Region selection, VPC endpoints, cross-region inference, prompt caching | AWS credential configuration in VS Code |
| **LiteLLM** | Organizations requiring multi-model access through a unified proxy | Proxy endpoint, authentication, model routing | API key or endpoint configuration in VS Code (or centralized with Master Key) |
| **Google Vertex AI** | Organizations using Google Cloud Platform | Project ID, region selection, model access | Service account or credential configuration in VS Code |
## Configuration Process
The typical remote configuration process follows these steps:
<Steps>
<Step title="Administrator Setup">
Access the Cline admin console and configure the desired inference provider with organization-wide settings.
</Step>
<Step title="Automatic Distribution">
Provider configuration is automatically distributed to all organization members signed into Cline.
</Step>
<Step title="Member Credential Setup">
Team members add their individual credentials (API keys, AWS profiles, etc.) to connect to the configured provider.
</Step>
<Step title="Immediate Access">
Once credentials are configured, members can immediately start using the inference provider through Cline.
</Step>
</Steps>
## Benefits of Remote Configuration
### **For Administrators**
- **Centralized Control**: Manage all provider settings from one location
- **Security Compliance**: Ensure consistent security policies across the organization
- **Easy Updates**: Change provider settings organization-wide instantly
### **For Team Members**
- **Simplified Setup**: No need to research provider configuration options
- **Consistent Experience**: Same models and features available to everyone
- **Quick Onboarding**: Get started immediately with pre-configured providers
- **Focus on Development**: Spend time coding instead of configuring inference providers
## Getting Started
To get started with provider remote configuration:
1. **Choose Your Provider**: Select the inference provider that best fits your organization's needs and existing infrastructure
2. **Admin Configuration**: Follow the provider-specific admin configuration guide
3. **Member Onboarding**: Have team members complete the provider-specific member configuration
4. **Start Developing**: Begin using Cline with centrally managed inference provider access
Select your provider below to begin the configuration process:
<CardGroup cols={3}>
<Card title="Amazon Bedrock" icon="aws" href="/enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration">
AWS-based AI models with enterprise security and compliance features.
</Card>
<Card title="LiteLLM" icon="layer-group" href="/enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration">
Unified proxy for accessing 100+ AI models through a single interface.
</Card>
<Card title="Google Vertex AI" icon="google" href="/enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration">
Google Cloud's AI platform with advanced ML capabilities and global infrastructure.
</Card>
</CardGroup>
@@ -1,63 +0,0 @@
---
title: "Managing Members"
sidebarTitle: "Managing Members"
description: "A guide to adding, removing, and editing members in your enterprise organization."
---
This guide covers the practical steps for adding, editing, and removing members from your enterprise dashboard. For a conceptual overview of roles and permissions, see the [Roles and Permissions](/enterprise-solutions/members/roles-and-permissions).
<Frame caption="The Members Dashboard provides a central place to manage your team.">
<img src="https://storage.googleapis.com/cline_public_images/members-dash.png" alt="Members Dashboard" />
</Frame>
## Adding Members
To invite someone to your organization, you must have an open seat available on your organization.
1. Navigate to the **Members** tab in your dashboard.
2. Click the **Add Members** button.
3. Enter one or more email addresses, separated by commas.
4. Select a role for the new member(s). It's best practice to start with the "Member" role unless you know they need admin privileges.
5. Click **Send Invitation**.
Invited users will receive an email with a link to join. You can cancel a pending invitation at any time by clicking the trash icon next to the user's email in the 'Pending Invites' section.
<Tip>
**Managing Users at Scale**
When inviting a large number of users, you can paste a comma-separated list of emails directly into the invitation field. While role changes and removals are performed individually, this bulk invitation feature helps streamline the onboarding process for entire teams.
</Tip>
<Frame caption="Adding members to your organization">
<img src="https://storage.googleapis.com/cline_public_images/adding-members.png" alt="Confirm Member Removal" />
</Frame>
## Editing Member Roles
As your team's needs change, you can adjust member roles directly from the dashboard.
- Find the member in your list.
- Under the "Role" column, click the dropdown menu.
- Select their new role. The change takes effect immediately.
Refer to the [Roles and Permissions](/enterprise-solutions/members/roles-and-permissions) for a detailed breakdown of what each role can do.
## Removing Members
Removing a member immediately revokes their access to all organization-specific resources, including shared API keys and configurations.
1. Go to the **Members Dashboard**.
2. Find the member in the list and click the red trash icon (<Icon icon="trash" iconType="solid" />).
3. Confirm the removal when prompted.
<Frame caption="You will be asked to confirm before a member is permanently removed.">
<img src="https://storage.googleapis.com/cline_public_images/remove-user.png" alt="Confirm Member Removal" />
</Frame>
## Troubleshooting Invitations
If an invited user is having trouble joining, check these common issues:
- **Invitation Not Received**: Ask the user to check their spam or junk mail folder. If it's not there, cancel the pending invitation and try sending it again, verifying the email address is correct.
- **"Invalid Domain" Error**: The user's email address must belong to a domain that has been verified for your organization. Work with your IT administrator to ensure the necessary domains are configured.
@@ -1,63 +0,0 @@
---
title: "Managing Members"
sidebarTitle: "Managing Members"
description: "A guide to adding, removing, and editing members in your enterprise organization."
---
This guide covers the practical steps for adding, editing, and removing members from your enterprise dashboard. For a conceptual overview of roles and permissions, see the [Roles and Permissions](/enterprise-solutions/members/roles-and-permissions).
<Frame caption="The Members Dashboard provides a central place to manage your team.">
<img src="https://storage.googleapis.com/cline_public_images/members-dash.png" alt="Members Dashboard" />
</Frame>
## Adding Members
To invite someone to your organization, you must have an open seat available on your organization.
1. Navigate to the **Members** tab in your dashboard.
2. Click the **Add Members** button.
3. Enter one or more email addresses, separated by commas.
4. Select a role for the new member(s). It's best practice to start with the "Member" role unless you know they need admin privileges.
5. Click **Send Invitation**.
Invited users will receive an email with a link to join. You can cancel a pending invitation at any time by clicking the trash icon next to the user's email in the 'Pending Invites' section.
<Tip>
**Managing Users at Scale**
When inviting a large number of users, you can paste a comma-separated list of emails directly into the invitation field. While role changes and removals are performed individually, this bulk invitation feature helps streamline the onboarding process for entire teams.
</Tip>
<Frame caption="Adding members to your organization">
<img src="https://storage.googleapis.com/cline_public_images/adding-members.png" alt="Confirm Member Removal" />
</Frame>
## Editing Member Roles
As your team's needs change, you can adjust member roles directly from the dashboard.
- Find the member in your list.
- Under the "Role" column, click the dropdown menu.
- Select their new role. The change takes effect immediately.
Refer to the [Roles and Permissions](/enterprise-solutions/members/roles-and-permissions) for a detailed breakdown of what each role can do.
## Removing Members
Removing a member immediately revokes their access to all organization-specific resources, including shared API keys and configurations.
1. Go to the **Members Dashboard**.
2. Find the member in the list and click the red trash icon (<Icon icon="trash" iconType="solid" />).
3. Confirm the removal when prompted.
<Frame caption="You will be asked to confirm before a member is permanently removed.">
<img src="https://storage.googleapis.com/cline_public_images/remove-user.png" alt="Confirm Member Removal" />
</Frame>
## Troubleshooting Invitations
If an invited user is having trouble joining, check these common issues:
- **Invitation Not Received**: Ask the user to check their spam or junk mail folder. If it's not there, cancel the pending invitation and try sending it again, verifying the email address is correct.
- **"Invalid Domain" Error**: The user's email address must belong to a domain that has been verified for your organization. Work with your IT administrator to ensure the necessary domains are configured.
@@ -1,27 +0,0 @@
---
title: "Members Overview"
sidebarTitle: "Overview"
description: "An overview of member management in your enterprise organization."
---
This section provides a comprehensive guide to managing members in your enterprise organization. Here, you'll find everything you need to know about roles, permissions, and the practical steps for adding, editing, and removing members from your dashboard.
## Key Topics
<CardGroup cols={2}>
<Card
title="Roles and Permissions"
icon="user-shield"
href="/enterprise-solutions/members/roles-and-permissions"
>
A detailed breakdown of the available roles and their specific permissions.
</Card>
<Card
title="Managing Members"
icon="users-gear"
href="/enterprise-solutions/members/managing-members"
>
A practical guide to adding, editing, and removing members from your
dashboard.
</Card>
</CardGroup>
@@ -1,83 +0,0 @@
---
title: "Roles and Permissions"
sidebarTitle: "Roles and Permissions"
description: "An overview of member roles, permissions, and best practices for your enterprise organization."
---
Choosing the right role for each member is crucial for maintaining security and ensuring your team can work effectively. This guide provides a detailed breakdown of the available roles, their specific permissions, and best practices for managing your organization.
## Role Definitions
Here’s a summary of the available roles and their intended use cases.
<CardGroup cols={1}>
<Card title="Owner" icon="user-crown">
**Best for:** The primary account holder or a small number of designated leaders.
Owners have unrestricted access to all settings, including billing, member management, and security configurations. To maintain tight control over the organization, the number of Owners should be kept to a minimum.
</Card>
<Card title="Admin" icon="user-gear">
**Best for:** Team leads or IT administrators who need to manage users and configurations.
Admins can invite, edit, and remove members, as well as manage provider configurations. They have broad access but cannot manage billing or change the Owner. This is a suitable role for trusted team managers.
</Card>
<Card title="Member" icon="user">
**Best for:** Most developers and individual contributors.
Members can use Cline with the organization's shared resources but cannot change any settings or view other users' activity. This is the safest default role for new users.
</Card>
</CardGroup>
## Permissions Matrix
For a detailed comparison, this matrix outlines the specific capabilities of each role.
| Permission | Member | Admin | Owner |
| --------------------------- | :----: | :----: | :----: |
| **General Usage** | | | |
| Use Cline | ✅ | ✅ | ✅ |
| Access Shared API Providers | ✅ | ✅ | ✅ |
| | | | |
| **Member Management** | | | |
| View Members | ❌ | ✅ | ✅ |
| Invite New Members | ❌ | ✅ | ✅ |
| Edit Member Roles | ❌ | ✅ | ✅ |
| Remove Members | ❌ | ✅ | ✅ |
| Remove Admins | ❌ | ❌ | ✅ |
| | | | |
| **Configuration** | | | |
| Configure API Providers | ❌ | ✅ | ✅ |
| Manage Security Settings | ❌ | ❌ | ✅ |
| | | | |
| **Billing & Ownership** | | | |
| View Billing Information | ❌ | ❌ | ✅ |
| Manage Subscription | ❌ | ❌ | ✅ |
| Transfer Ownership | ❌ | ❌ | ✅ |
## Role Management Best Practices
Effective role management is fundamental to securing your organization.
- **Apply the Principle of Least Privilege**: Always assign the role with the minimum necessary permissions. Most users should be **Members**. Grant **Admin** rights only to those who are responsible for user management or technical configuration.
- **Limit the Number of Owners**: The **Owner** role should be reserved for one or two key individuals who control the account and billing. This centralization of power prevents accidental or malicious changes to critical settings.
- **Regularly Audit Roles**: Periodically review the list of Admins and Owners to ensure the assigned roles are still appropriate. When a team member's responsibilities change, adjust their role accordingly.
## Identity Providers and Domain Verification
For a user to successfully join and sign in to your organization, two conditions must be met:
1. Their email must be managed by your organization's verified **Identity Provider (IDP)**, such as Microsoft Entra ID, Okta, or AWS.
2. Your organization must have a **verified domain** with a provider like Google or Microsoft.
This ensures that only authenticated users from your company can access your Cline organization.
## Seat Management and Invitations
Each user in your organization, regardless of role, consumes one seat from your license.
- When an invitation is sent, a seat is considered "pending."
- If an invited user does not accept, the invitation can be revoked to free up the seat.
- Removing a member from the organization immediately frees up a seat.
Now that you understand the different roles and how to manage them, you can proceed to [configuring provider remote access](/enterprise-solutions/provider-remote-config/aws-bedrock/admin-configuration) for your organization.
@@ -0,0 +1,266 @@
---
title: "OpenTelemetry Integration"
sidebarTitle: "OpenTelemetry"
description: "Export Cline telemetry to your observability platform using OpenTelemetry Protocol (OTLP)"
---
Cline includes opt-in OpenTelemetry support for exporting metrics and logs to your own observability infrastructure using the OpenTelemetry Protocol (OTLP).
<Note>
OpenTelemetry integration is **optional** and intended for advanced users with existing observability infrastructure. Most users won't need this feature.
</Note>
## What is OpenTelemetry?
[OpenTelemetry](https://opentelemetry.io/) is an industry-standard observability framework that provides a unified way to collect and export telemetry data (metrics, logs, and traces).
Cline's OpenTelemetry support allows you to:
- Export telemetry to your own systems
- Integrate with observability platforms like Datadog, New Relic, Grafana Cloud, etc.
- Maintain full control over your monitoring data
- Use your organization's existing monitoring infrastructure
## Supported Features
Cline supports OpenTelemetry's **OTLP (OpenTelemetry Protocol)** export with:
<CardGroup cols={2}>
<Card title="Metrics Export" icon="chart-bar">
Export metrics about Cline usage, performance, and errors
</Card>
<Card title="Logs Export" icon="file-lines">
Export structured logs for debugging and analysis
</Card>
</CardGroup>
### Export Formats
Cline supports three OTLP export protocols:
- **gRPC** (default, recommended)
- **HTTP/protobuf**
- **HTTP/JSON**
### Export Destinations
You can export to:
- **Console** (for testing)
- **OTLP endpoint** (your own collector or observability platform)
## Configuration
OpenTelemetry is configured using environment variables before launching Cline.
### Basic Setup
Enable OpenTelemetry and configure an OTLP endpoint:
```bash
# Enable OpenTelemetry
export OTEL_TELEMETRY_ENABLED=1
# Configure metrics and logs export
export OTEL_METRICS_EXPORTER=otlp
export OTEL_LOGS_EXPORTER=otlp
# Set your OTLP endpoint
export OTEL_EXPORTER_OTLP_ENDPOINT=https://your-collector:4317
# Optional: Set protocol (default is grpc)
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
```
### Environment Variables
| Variable | Description | Default |
|----------|-------------|---------|
| `OTEL_TELEMETRY_ENABLED` | Enable OpenTelemetry (`1` or `true`) | Disabled |
| `OTEL_METRICS_EXPORTER` | Metrics exporter type (`console`, `otlp`, or both) | None |
| `OTEL_LOGS_EXPORTER` | Logs exporter type (`console`, `otlp`, or both) | None |
| `OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP endpoint URL | None |
| `OTEL_EXPORTER_OTLP_PROTOCOL` | Protocol (`grpc`, `http/protobuf`, `http/json`) | `grpc` |
| `OTEL_EXPORTER_OTLP_INSECURE` | Allow insecure connections | `false` |
| `OTEL_EXPORTER_OTLP_HEADERS` | Custom headers (comma-separated `key=value` pairs) | None |
### Advanced Configuration
**Separate endpoints for metrics and logs:**
```bash
export OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=https://metrics-collector:4317
export OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=https://logs-collector:4317
```
**Custom headers for authentication:**
```bash
export OTEL_EXPORTER_OTLP_HEADERS="api-key=your-key,x-custom-header=value"
```
**Multiple exporters (console + OTLP):**
```bash
export OTEL_METRICS_EXPORTER=console,otlp
export OTEL_LOGS_EXPORTER=console,otlp
```
**Export intervals:**
```bash
# Metrics export interval in milliseconds (default: 60000)
export OTEL_METRIC_EXPORT_INTERVAL=30000
# Logs batch size and timeout
export OTEL_LOG_BATCH_SIZE=512
export OTEL_LOG_BATCH_TIMEOUT=5000
export OTEL_LOG_MAX_QUEUE_SIZE=2048
```
## Integration Examples
### Datadog
Export to Datadog using their OTLP endpoint:
```bash
export OTEL_TELEMETRY_ENABLED=1
export OTEL_METRICS_EXPORTER=otlp
export OTEL_LOGS_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_ENDPOINT=https://api.datadoghq.com
export OTEL_EXPORTER_OTLP_HEADERS="dd-api-key=YOUR_DD_API_KEY"
```
### New Relic
Export to New Relic:
```bash
export OTEL_TELEMETRY_ENABLED=1
export OTEL_METRICS_EXPORTER=otlp
export OTEL_LOGS_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp.nr-data.net:4317
export OTEL_EXPORTER_OTLP_HEADERS="api-key=YOUR_NEW_RELIC_LICENSE_KEY"
```
### Grafana Cloud
Export to Grafana Cloud:
```bash
export OTEL_TELEMETRY_ENABLED=1
export OTEL_METRICS_EXPORTER=otlp
export OTEL_LOGS_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp-gateway-prod-us-central-0.grafana.net/otlp
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Basic YOUR_BASE64_CREDENTIALS"
```
## Testing Configuration
Test your configuration with console output before sending to a real endpoint:
```bash
# Enable console output to see what data would be exported
export OTEL_TELEMETRY_ENABLED=1
export OTEL_METRICS_EXPORTER=console
export OTEL_LOGS_EXPORTER=console
```
Then launch Cline and check the console output for metrics and logs.
## Troubleshooting
### No Data Being Exported
1. **Verify OpenTelemetry is enabled:**
```bash
echo $OTEL_TELEMETRY_ENABLED
```
Should output `1` or `true`
2. **Check exporters are configured:**
```bash
echo $OTEL_METRICS_EXPORTER
echo $OTEL_LOGS_EXPORTER
```
3. **Test with console exporter first:**
```bash
export OTEL_METRICS_EXPORTER=console
export OTEL_LOGS_EXPORTER=console
```
### Connection Errors
1. **Verify endpoint is accessible:**
```bash
curl -v https://your-otlp-endpoint:4317
```
2. **Check if insecure mode is needed:**
```bash
export OTEL_EXPORTER_OTLP_INSECURE=true
```
3. **Verify authentication headers:**
Double-check your API keys and authentication headers are correct
### Debug Mode
Enable debug logging to see detailed OpenTelemetry information:
```bash
export TEL_DEBUG_DIAGNOSTICS=true
```
This will output detailed information about:
- Configuration being used
- Exporters being created
- Connection attempts
- Export successes/failures
## What Gets Exported
When Opentelemetry is enabled, Cline exports:
### Metrics
- Feature usage counts
- Task execution metrics
- Error rates and types
- Performance measurements
### Logs
- System events
- Error logs with context
- Operational information
<Warning>
Exported data is already anonymous and doesn't include code content, file paths, or sensitive information. However, you're responsible for securing the data once exported to your systems.
</Warning>
## Limitations
Current OpenTelemetry support in Cline:
- ✅ OTLP metrics export (console, gRPC, HTTP)
- ✅ OTLP logs export (console, gRPC, HTTP)
- ✅ Basic configuration via environment variables
- ❌ Distributed tracing (not yet implemented)
- ❌ Custom instrumentation API (not yet exposed)
- ❌ Sampling configuration (uses defaults)
## Best Practices
1. **Test First**: Always test with console exporter before sending to production
2. **Secure Credentials**: Never hardcode API keys; use secure environment variable management
3. **Monitor Costs**: Be aware of data ingestion costs with your observability platform
4. **Start Simple**: Begin with metrics only, add logs if needed
5. **Use Compression**: OTLP supports compression; check if your endpoint requires it
## Next Steps
<CardGroup cols={2}>
<Card title="Cline Telemetry" icon="chart-simple" href="/enterprise-solutions/monitoring/telemetry">
Configure simple built-in telemetry
</Card>
<Card title="OpenTelemetry Docs" icon="book" href="https://opentelemetry.io/docs/">
Learn more about OpenTelemetry
</Card>
</CardGroup>
@@ -0,0 +1,111 @@
---
title: "Enterprise Monitoring"
sidebarTitle: "Overview"
description: "Optional telemetry and observability for your Cline deployment"
---
Cline includes optional monitoring capabilities for organizations that want to track usage and integrate with their observability infrastructure.
## Monitoring Options
<CardGroup cols={2}>
<Card title="Cline Telemetry" icon="chart-simple" href="/enterprise-solutions/monitoring/telemetry">
Built-in anonymous usage tracking that helps improve Cline (opt-in)
</Card>
<Card title="OpenTelemetry" icon="chart-line" href="/enterprise-solutions/monitoring/opentelemetry">
Export metrics and logs to your own observability backends (advanced)
</Card>
</CardGroup>
## Cline Telemetry
Cline includes opt-in telemetry for anonymous usage tracking:
- Feature usage patterns
- Task completion rates
- Error occurrences
- Performance metrics
Users can enable or disable telemetry in Cline settings. All data is anonymous and does not include code content, file paths, or sensitive information.
See [Cline Telemetry](/enterprise-solutions/monitoring/telemetry) for configuration details.
## OpenTelemetry Integration
For advanced monitoring needs, Cline supports OpenTelemetry's OTLP (OpenTelemetry Protocol) for exporting metrics and logs to your own infrastructure.
This allows you to:
- Export telemetry to your existing observability platforms
- Integrate with tools like Datadog, New Relic, or Grafana Cloud
- Maintain full control over your monitoring data
- Aggregate metrics across your organization
<Note>
OpenTelemetry integration is **optional** and requires additional configuration. Most users don't need this feature.
</Note>
See [OpenTelemetry](/enterprise-solutions/monitoring/opentelemetry) for setup instructions.
## Use Cases
### When to Use Cline Telemetry
- You want to help improve Cline through anonymous usage data
- No additional setup required
- Suitable for most users
### When to Use OpenTelemetry
- You need granular metrics in your own systems
- You're integrating with existing observability infrastructure
- You want detailed logs and metrics for debugging
- You need custom dashboards or alerting
## Getting Started
<Steps>
<Step title="Choose Your Approach">
Decide whether basic telemetry or OpenTelemetry integration fits your needs
</Step>
<Step title="Enable Telemetry">
For basic telemetry, enable it in Cline settings. For OpenTelemetry, see the configuration guide.
</Step>
<Step title="Verify Data Collection">
Confirm telemetry is being collected as expected
</Step>
</Steps>
## Privacy & Security
All Cline monitoring features are designed with privacy in mind:
<CardGroup cols={2}>
<Card title="Anonymous" icon="user-secret">
No personal information collected
</Card>
<Card title="Optional" icon="toggle-on">
Users can disable at any time
</Card>
<Card title="Local First" icon="laptop">
Code never leaves your machine
</Card>
<Card title="Transparent" icon="code">
Open source - see what's collected
</Card>
</CardGroup>
## Next Steps
<CardGroup cols={2}>
<Card title="Configure Telemetry" icon="gear" href="/enterprise-solutions/monitoring/telemetry">
Set up basic telemetry settings
</Card>
<Card title="OpenTelemetry Setup" icon="chart-line" href="/enterprise-solutions/monitoring/opentelemetry">
Advanced monitoring with OpenTelemetry
</Card>
</CardGroup>
@@ -0,0 +1,133 @@
---
title: "Cline Telemetry"
sidebarTitle: "Cline Telemetry"
description: "Configure usage analytics and event tracking"
---
Cline includes telemetry to help understand usage patterns and improve the product. Users can control whether to share this data.
## What is Cline Telemetry?
Telemetry captures anonymous usage events such as:
- Features used (which tools, commands, workflows)
- Task completion rates
- Error occurrences
- Performance metrics
<Info>
All telemetry data is **anonymous** and does not include code content, file contents, or other sensitive information.
</Info>
## User Controls
### Enabling/Disabling Cline Telemetry
Individual users can control telemetry through Cline settings:
1. Open Cline settings
2. Find "Cline Telemetry" toggle
3. Enable or disable as preferred
Changes take effect immediately.
### What Gets Collected
When telemetry is enabled, Cline captures:
<AccordionGroup>
<Accordion title="Feature Usage" icon="cursor-click">
- Tools executed (e.g., read_file, execute_command)
- Slash commands used
- Workflows triggered
- Settings changed
</Accordion>
<Accordion title="Task Metrics" icon="tasks">
- Task started/completed events
- Mode switches (Plan/Act)
- Checkpoint usage
- Task duration
</Accordion>
<Accordion title="Error Events" icon="triangle-exclamation">
- API failures
- Tool execution errors
- System errors
- Error types and frequencies
</Accordion>
</AccordionGroup>
### What Doesn't Get Collected
Cline Telemetry **never** includes:
- Your code or file contents
- File paths or names
- Command arguments or parameters
- Conversation content
- Personal information
- API keys or credentials
## Enterprise Configuration
Administrators can set default telemetry state through remote configuration:
```json
{
"telemetryEnabled": true
}
```
<Note>
Even with enterprise configuration, individual users can still disable Cline Telemetry in their local settings.
</Note>
## Advanced Monitoring
For organizations needing detailed monitoring, Cline supports optional OpenTelemetry integration to export telemetry data to your own observability systems.
See [Enterprise Monitoring](/enterprise-solutions/monitoring/overview) for details on available monitoring options.
## Privacy
Cline's telemetry is designed with privacy in mind:
<CardGroup cols={2}>
<Card title="Anonymous" icon="user-secret">
No personal information is collected
</Card>
<Card title="Optional" icon="toggle-on">
Users can disable at any time
</Card>
<Card title="Local First" icon="laptop">
Code never leaves your machine
</Card>
<Card title="Transparent" icon="eye">
Open source - see exactly what's collected
</Card>
</CardGroup>
## Why Telemetry Matters
Anonymous usage data helps:
- **Identify bugs**: Discover issues affecting users
- **Prioritize features**: Focus on most-used capabilities
- **Improve performance**: Find and fix slow operations
- **Enhance reliability**: Track and reduce error rates
## Related
<CardGroup cols={2}>
<Card title="OpenTelemetry" icon="chart-line" href="/enterprise-solutions/monitoring/opentelemetry">
Enterprise monitoring and observability
</Card>
<Card title="Privacy" icon="shield" href="/more-info/telemetry">
Full telemetry documentation
</Card>
</CardGroup>
+1 -1
View File
@@ -51,7 +51,7 @@ User roles are mapped automatically from your IdP:
- **Member** in IdP → **Member** role in Cline
<Info>
For what each role can access, see the [Roles and Permissions](./members/roles-and-permissions) page.
For what each role can access, see the [Roles and Permissions](/enterprise-solutions/team-management/managing-members) page.
</Info>
If needed, you can configure additional user attributes in the Cline Admin console:
+5 -5
View File
@@ -1,7 +1,7 @@
---
title: "Cline Enterprise"
sidebarTitle: "Overview"
description: "Enterprise security, governance, and observability for the coding agent 3 million developers trust"
description: "Enterprise security, governance, and observability for the coding agent millions of developers trust"
---
Cline Enterprise brings centralized governance to the same open-source architecture that millions of developers already use. Your code stays in your environment, you use your own inference at your negotiated rates, and you get the security and observability capabilities that platform teams need for org-wide deployment.
@@ -57,10 +57,10 @@ Platform teams need central control when thousands of developers use AI. Individ
Enterprise governance provides:
- **SSO authentication**: Corporate credentials instead of personal API keys
- **Role-based access control**: Fine-grained permissions per team and project
- **Role-based access control**: Three-tier hierarchy (Member/Admin/Owner) with organization-scoped permissions
- **Model and tool controls**: Govern which models and tools each team accesses
- **Remote configuration**: Manage settings for all developers from one dashboard
- **Full audit logging**: Every AI interaction tracked with detailed logs
- **Usage tracking and observability**: OpenTelemetry integration for monitoring usage, costs, and performance with selective audit logging for administrative operations
Configure once, deploy everywhere. Developers work how they prefer while you maintain control.
@@ -77,7 +77,7 @@ The same observability standards you require for production systems.
## Deployment
Cline Enterprise connects securely to your infrastructure. Deploy in cloud environments, on-premises, or air-gapped networks. Configure to work with your existing security policies and compliance requirements.
Cline Enterprise connects securely to your infrastructure. Deploy in cloud environments. Configure to work with your existing security policies and compliance requirements.
Rolling out to your organization:
1. Configure Cline Core to connect to your infrastructure
@@ -87,7 +87,7 @@ Rolling out to your organization:
## Next Steps
- Review [security architecture](/enterprise-solutions/security-concerns)
- Review security architecture
- Configure [cloud provider setup](/provider-config/aws-bedrock/api-key) (AWS Bedrock, Vertex AI, Azure)
- Set up [MCP servers](/mcp/mcp-overview) for custom tooling
- Add [custom instructions](/features/cline-rules) for your codebase
@@ -0,0 +1,317 @@
---
title: "Managing Members"
sidebarTitle: "Managing Members"
description: "Complete guide to managing team members, roles, and permissions in your Cline Enterprise organization"
---
Effective member management is essential for maintaining security and enabling your team to work productively. This guide covers everything you need to know about roles, permissions, and day-to-day member administration.
## Understanding Roles
Choose the right role for each team member to balance security with productivity. Here's what each role is designed for:
<CardGroup cols={3}>
<Card title="Owner" icon="crown" color="#9D4EDD">
**Primary account holder**
Unrestricted access to all settings including billing, security, and ownership transfer. Keep this limited to 1-2 key leaders.
</Card>
<Card title="Admin" icon="user-gear" color="#7209B7">
**Team leads & IT managers**
Can manage users and configure providers. Ideal for trusted managers who need operational control without billing access.
</Card>
<Card title="Member" icon="user" color="#560BAD">
**Developers & contributors**
Can use Cline with shared resources but cannot change settings. The safest default for most team members.
</Card>
</CardGroup>
## Permissions Matrix
Understand exactly what each role can do with this comprehensive permissions breakdown:
| Permission | Member | Admin | Owner |
| :--- | :---: | :---: | :---: |
| **General Usage** | | | |
| Use Cline | ✅ | ✅ | ✅ |
| Access Shared API Providers | ✅ | ✅ | ✅ |
| | | | |
| **Member Management** | | | |
| View Members | ❌ | ✅ | ✅ |
| Invite New Members | ❌ | ✅ | ✅ |
| Edit Member Roles | ❌ | ✅ | ✅ |
| Remove Members | ❌ | ✅ | ✅ |
| Remove Admins | ❌ | ❌ | ✅ |
| | | | |
| **Configuration** | | | |
| Configure API Providers | ❌ | ✅ | ✅ |
| Manage Security Settings | ❌ | ❌ | ✅ |
| | | | |
| **Billing & Ownership** | | | |
| View Billing Information | ❌ | ❌ | ✅ |
| Manage Subscription | ❌ | ❌ | ✅ |
| Transfer Ownership | ❌ | ❌ | ✅ |
<Note>
**Quick Reference:** Most users should be **Members**. Grant **Admin** only to those managing users or configs. Reserve **Owner** for 1-2 account leaders.
</Note>
## Member Management Tasks
<Tabs>
<Tab title="Adding Members">
### Inviting New Team Members
1. **Navigate to Members**
- Go to your organization dashboard at app.cline.bot
- Click on "Members" in the sidebar
2. **Send Invitation**
- Click "Invite Member"
- Enter the user's email address (must be from your verified domain)
- Select the appropriate role (Member, Admin, or Owner)
- Click "Send Invite"
3. **Invitation Status**
- Invited users will receive an email with a join link
- Pending invitations show in your member list with "Pending" status
- Each pending invitation holds one seat from your license
<Tip>
**Bulk Invitations:** Need to add multiple users? Contact support@cline.bot for assistance with bulk invite CSV imports.
</Tip>
</Tab>
<Tab title="Editing Roles">
### Changing Member Permissions
1. **Locate the Member**
- Navigate to the Members page
- Find the user you want to modify
2. **Change Role**
- Click the dropdown next to their current role
- Select the new role from the menu
- Confirm the change
3. **Effective Immediately**
- Role changes take effect instantly
- The user may need to sign out and back in to see updated permissions
<Warning>
**Admin to Member:** Downgrading an Admin to Member will immediately revoke their ability to manage users and configurations. Ensure they no longer need these permissions.
</Warning>
</Tab>
<Tab title="Removing Members">
### Offboarding Team Members
1. **Access Member List**
- Navigate to your organization's Members page
- Locate the user to remove
2. **Remove User**
- Click the menu icon (⋮) next to their name
- Select "Remove from Organization"
- Confirm the removal
3. **Immediate Effects**
- User loses access to the organization immediately
- Their seat is freed and can be assigned to someone else
- Audit logs are preserved for compliance
<Info>
**Data Retention:** Removing a member does not delete their historical activity logs. All audit trails remain intact for compliance purposes.
</Info>
</Tab>
<Tab title="Revoking Invites">
### Canceling Pending Invitations
If an invited user hasn't accepted yet, you can revoke the invitation:
1. Find the pending invitation in your Members list
2. Click "Revoke Invitation"
3. The seat is immediately freed for another user
This is useful when:
- The wrong email was used
- The user no longer needs access
- You need to reassign the seat urgently
</Tab>
</Tabs>
## Identity & Access Requirements
For users to successfully join your organization, two conditions must be met:
<Steps>
<Step title="Verified Identity Provider">
Your organization must use a verified **Identity Provider (IDP)** such as:
- Microsoft Entra ID (Azure AD)
- Okta
- Google Workspace
- AWS IAM Identity Center
Users must authenticate through your IDP to access the organization.
</Step>
<Step title="Domain Verification">
Your organization must have a **verified domain**. You'll need to verify ownership of your domain through your domain provider (e.g., Google, Microsoft, Cloudflare).
Only users with email addresses from verified domains can join.
</Step>
</Steps>
<Note>
These requirements ensure that only authenticated users from your company can access your Cline organization, preventing unauthorized access.
</Note>
## Seat Management
Understanding how seats work helps you manage your license effectively:
<AccordionGroup>
<Accordion title="How Seats Are Calculated" icon="chair">
- Each user (Owner, Admin, or Member) consumes **one seat**
- Pending invitations also hold one seat
- Removing a member or revoking an invite immediately frees the seat
- Your license determines the maximum number of seats available
</Accordion>
<Accordion title="When Seats Are Used" icon="user-plus">
A seat is consumed when:
- You send an invitation (marked as "pending")
- An invited user accepts and joins
- An existing user is granted access through SSO
</Accordion>
<Accordion title="Freeing Up Seats" icon="user-minus">
To free a seat:
- Remove an active member from the organization
- Revoke a pending invitation
- Wait for a pending invite to expire (if configured)
</Accordion>
<Accordion title="Upgrading Your License" icon="arrow-up">
Need more seats?
- **Teams Plan:** Contact your account manager or visit app.cline.bot/settings/billing to upgrade your license.
- **Enterprise Plan:** Includes unlimited seats with no per-user restrictions.
</Accordion>
</AccordionGroup>
## Security Best Practices
Follow these guidelines to maintain a secure organization:
<CardGroup cols={2}>
<Card title="Principle of Least Privilege" icon="shield-check">
Always assign the minimum role necessary. Most users should be Members. Only grant Admin or Owner privileges when required for job duties.
</Card>
<Card title="Limit Owner Roles" icon="user-lock">
Keep Owners to 1-2 key individuals who manage billing and security. This centralization prevents accidental or malicious changes to critical settings.
</Card>
<Card title="Regular Audits" icon="clipboard-check">
Review your member list quarterly. Remove inactive users promptly and verify that Admin/Owner roles are still appropriate for each user.
</Card>
<Card title="Offboarding Process" icon="door-open">
Create a standard offboarding checklist: remove from Cline, revoke IDP access, document in audit log, and reassign any critical responsibilities.
</Card>
</CardGroup>
<Warning>
**Owner Accountability:** Since Owners control billing and can transfer ownership, choose these individuals carefully and document the selection in your organization's security policies.
</Warning>
## Advanced Scenarios
<AccordionGroup>
<Accordion title="Transferring Ownership" icon="exchange">
Only the current Owner can transfer ownership:
1. Navigate to Organization Settings
2. Go to the "Ownership" section
3. Select the new Owner from the member list
4. Confirm the transfer with your authentication
5. The new Owner receives immediate control
**Important:** This action cannot be undone by the previous Owner. The new Owner must initiate a reverse transfer if needed.
</Accordion>
<Accordion title="Managing Multiple Admins" icon="users-gear">
When you have multiple Admins:
- Document each Admin's area of responsibility
- Use audit logs to track configuration changes
- Consider creating rotation schedules for large teams
- Establish escalation paths for Owner-level decisions
</Accordion>
<Accordion title="Temporary Access" icon="clock">
For contractors or temporary staff:
- Create them as Members with expiration calendar reminders
- Document their access period in your internal systems
- Set calendar reminders to remove them when the contract ends
- Consider using time-limited IDP accounts if your IDP supports it
</Accordion>
</AccordionGroup>
## Troubleshooting
<AccordionGroup>
<Accordion title="User Can't Accept Invitation" icon="circle-exclamation">
**Common causes:**
- Email domain doesn't match verified domain
- User's IDP access hasn't been granted yet
- Invitation link expired
**Solution:** Verify domain verification is complete and resend the invitation.
</Accordion>
<Accordion title="Can't Remove an Admin" icon="user-slash">
**Cause:** Only Owners can remove Admins.
**Solution:** Ask an Owner to perform the removal, or if you need to remove your organization's sole Owner, contact support@cline.bot.
</Accordion>
<Accordion title="Out of Seats" icon="triangle-exclamation">
**When you've reached your license limit:**
- Remove inactive members to free seats
- Revoke pending invitations that are no longer needed
- Upgrade your license to add more seats
</Accordion>
</AccordionGroup>
## Next Steps
Now that you understand member management, proceed with configuring your organization:
<CardGroup cols={2}>
<Card
title="Configure Providers"
icon="plug"
href="/enterprise-solutions/configuration/choosing-your-deployment"
>
Set up API providers for your team to use
</Card>
<Card
title="Monitor Usage"
icon="chart-line"
href="/enterprise-solutions/monitoring/overview"
>
Track team activity and resource consumption
</Card>
</CardGroup>
<Tip>
**Getting Started Fast?** The quickest path is: 1) Invite your team as Members, 2) Configure one API provider, 3) Let your team start using Cline. You can refine roles and settings later.
</Tip>