create-provider
/create-provider
Create new AtlasClaw providers with proper structure, documentation, and skills. Use when building integrations with external systems like APIs, ITSM, CRM, or custom services.
- Author
- CloudChef ↗
- Repository
- atlasclaw-providers ↗
- Licence
- Apache-2.0
- Last repository change
- 03.09.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 4
No signals detected. Repository changed on 03.09.2026, without references to retired models or APIs.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
What it does and when to use it
Create new AtlasClaw providers with proper structure, documentation, and skills. Use when building integrations with external systems like APIs, ITSM, CRM, or custom services.
Original author description
Create new AtlasClaw providers with proper structure, documentation, and skills. Use when building integrations with external systems like APIs, ITSM, CRM, or custom services.
How it works
- Quick Start Checklist
- Phase 1: Gather Requirements
- Phase 2: Directory Structure
- Phase 3: PROVIDER.md Template
- Phase 4: SKILL.md Template
- Phase 5: Handler Template
- Phase 6: Configuration
- Phase 7: Verification
- LLM Context Best Practices
- Common Provider Types
SKILL.md preview
---
name: create-provider
description: Create new AtlasClaw providers with proper structure, documentation, and skills. Use when building integrations with external systems like APIs, ITSM, CRM, or custom services.
---
# Create AtlasClaw Provider
Guide for creating new providers that integrate external systems with the AtlasClaw AI Agent.
## Quick Start Checklist
```
Provider Creation Progress:
- [ ] 1. Gather requirements (system type, auth method, capabilities)
- [ ] 2. Create provider directory structure
- [ ] 3. Write PROVIDER.md with LLM context fields
- [ ] 4. Create skills for each capability
- [ ] 5. Add configuration to atlasclaw.json
- [ ] 6. Test provider loading and skill execution
```
## Phase 1: Gather Requirements
Before creating a provider, determine:
| Question | Example Answer |
|----------|----------------|
| **Provider type** | `servicenow`, `github`, `datadog` |
| **Display name** | ServiceNow, GitHub, Datadog |
| **Authentication method** | Basic Auth, API Token, OAuth 2.0, Cookie |
| **Base URL pattern** | `https://instance.service-now.com` |
| **Key capabilities** | CRUD incidents, manage users, query metrics |
| **Target keywords** | incident, ticket, alert, deployment |
## Phase 2: Directory Structure
Create provider at: `{workspace}/providers/{provider-name}/`
```
providers/{provider-name}/
├── PROVIDER.md # Required - provider metadata and documentation
├── README.md # Optional - human documentation
├── skills/ # Required - at least one skill
│ └── {skill-name}/
│ ├── SKILL.md # Required - skill metadata
│ └── scripts/ # Required for executable skills
│ └── handler.py
└── references/ # Optional - API docs, mappings
└── api_mapping.md
```
## Phase 3: PROVIDER.md Template
```yaml
---
# === Required Fields ===
provider_type: {provider-name} # Must match directory name
display_name: {Display Name}
version: "1.0.0"
# === LLM Context Fields (for Skill Discovery) ===
keywords:
- keyword1 # Domain-specific terms users might say
- keyword2
- keyword3
capabilities:
- Capability description 1
- Capability description 2
use_when:
- User intent scenario 1
- User intent scenario 2
avoid_when:
- Scenario when other provider is better (suggest alternative)
---
# {Display Name} Provider
Brief description of what this provider integrates with.
## Connection Parameters
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `base_url` | string | Yes | API base URL |
| `username` | string | Conditional | Username for auth |
| `password` | string | Conditional | Password or token |
| `api_key` | string | Conditional | API key if applicable |
## Authentication Modes
| Mode | Parameters | Notes |
|------|------------|-------|
| Basic Auth | `username` + `password` | Standard HTTP Basic |
| API Token | `api_key` | Bearer token auth |
## Configuration Example
```json
{
"service_providers": {
"{provider-name}": {
"default": {
"base_url": "${PROVIDER_URL}",
"api_key": "${PROVIDER_API_KEY}"
}
}
}
}
```
## Environment Variables
```bash
PROVIDER_URL=https://api.example.com
PROVIDER_API_KEY=your-api-key
```
## Provided Skills
| Skill | Description |
|-------|-------------|
| `{provider}-{action}` | Brief description |
```
## Phase 4: SKILL.md Template
```yaml
---
name: "{provider}-{action}"
description: "Brief description. Trigger when user wants to {action}."
category: "provider:{provider-name}"
provider_type: "{provider-name}"
instance_required: "true"
# === LLM Context Fields ===
triggers:
- action phrase 1
- action phrase 2
use_when:
- User intent scenario 1
- User intent scenario 2
avoid_when:
- Scenario when other skill is better
examples:
- "Example user input 1"
- "Example user input 2"
related:
- related-skill-1
- related-skill-2
# === Tool Registration ===
tool_name: "{provider}_{action}"
tool_entrypoint: "scripts/handler.py:handler"
---
# {provider}-{action}
## Purpose
What this skill does and when to use it.
## Parameters
| Name | Type | Required | Description |
|------|------|----------|-------------|
| param1 | string | Yes | Description |
| param2 | integer | No | Description (default: 10) |
## Usage Examples
**Example 1**: Basic usage
```bash
python scripts/handler.py --param1 "value"
```
## Error Handling
| Error | Cause | Resolution |
|-------|-------|------------|
| AUTH_FAILED | Invalid credentials | Check API key |
```
## Phase 5: Handler Template
Create `scripts/handler.py`:
```python
# -*- coding: utf-8 -*-
"""
{Skill Name} Handler
Implements the {action} functionality for {Provider} provider.
"""
from __future__ import annotations
import argparse
import json
import os
import sys
from typing import Any, Optional
import requests
def get_provider_config() -> dict[str, Any]:
"""Load provider configuration from atlasclaw.json."""
config_path = os.environ.get("ATLASCLAW_CONFIG", "atlasclaw.json")
with open(config_path, "r", encoding="utf-8") as f:
config = json.load(f)
provider_config = config.get("service_providers", {}).get("{provider-name}", {})
instance = os.environ.get("PROVIDER_INSTANCE", "default")
return provider_config.get(instance, {})
def handler(params: dict[str, Any]) -> dict[str, Any]:
"""
Main handler function.
Args:
params: Input parameters
Returns:
Result dictionary with success, message, and data
"""
config = get_provider_config()
base_url = config.get("base_url", "").rstrip("/")
api_key = config.get("api_key", "")
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
try:
# Implement API call here
response = requests.get(
f"{base_url}/api/endpoint",
headers=headers,
timeout=30
)
response.raise_for_status()
return {
"success": True,
"message": "Operation completed successfully",
"data": response.json()
}
except requests.RequestException as e:
return {
"success": False,
"message": f"API request failed: {str(e)}",
"error": {"code": "API_ERROR", "details": str(e)}
}
def main():
"""CLI entry point."""
parser = argparse.ArgumentParser(description="{Skill description}")
parser.add_argument("--param1", required=True, help="Parameter 1")
parser.add_argument("--param2", type=int, default=10, help="Parameter 2")
args = parser.parse_args()
result = handler({
"param1": args.param1,
"param2": args.param2
})
print(json.dumps(result, indent=2))
sys.exit(0 if result["success"] else 1)
if __name__ == "__main__":
main()
```
## Phase 6: Configuration
Add to `atlasclaw.json`:
```json
{
"service_providers": {
"{provider-name}": {
"default": {
"base_url": "${PROVIDER_URL}",
"api_key": "${PROVIDER_API_KEY}"
},
"production": {
"base_url": "${PROVIDER_PROD_URL}",
"api_key": "${PROVIDER_PROD_API_KEY}"
}
}
}
}
```
Add to `.env`:
```bash
PROVIDER_URL=https://api.example.com
PROVIDER_API_KEY=your-api-key
```
## Phase 7: Verification
1. **Restart service** (or wait for hot reload)
2. **Check logs** for provider loading:
```
[AtlasClaw] Provider loaded: {provider-name}
[AtlasClaw] Skills loaded: X from {provider-name}
```
3. **Test via API**:
```bash
curl http://localhost:8000/api/skills | grep {provider-name}
```
## LLM Context Best Practices
### Keywords
- Use domain-specific terms users naturally say
- Avoid generic terms like "create", "update", "manage"
- Include abbreviations and synonyms
### use_when
- Describe user intent, not technical actions
- Focus on business scenarios
- Include common phrasings
### avoid_when
- Critical for disambiguation between similar providers
- Always suggest the correct alternative
- Include commonly confused scenarios
## Common Provider Types
| Type | Examples | Typical Keywords |
|------|----------|------------------|
| ITSM | ServiceNow, Jira | incident, ticket, issue, sprint |
| Monitoring | Datadog, Prometheus | alert, metric, dashboard |
| Communication | Slack, Teams | message, channel, notification |
| Version Control | GitHub, GitLab | repository, PR, merge, commit |
| CRM | Salesforce | lead, opportunity, account |
| Cloud | AWS, Azure | instance, resource, deployment |
## Additional Resources
- [PROVIDER_GUIDE.md](file:///c:/Projects/cmps/atlasclaw/docs/PROVIDER_GUIDE.md) - Full documentation
- [SKILL_GUIDE.md](file:///c:/Projects/cmps/atlasclaw/docs/SKILL_GUIDE.md) - Skill development guide
- [Jira Provider](file:///c:/Projects/cmps/atlasclaw/.atlasclaw/providers/jira) - Reference implementation
Files in this package (2)
- SKILL.md 9 KB
- templates.md 4 KB
Versions
The database has no other skills named create-provider.
Database snapshot: 13.11.2026 · package version a8b5ab3d218d (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100create-atlasclaw-skill
Create new AtlasClaw skills with proper structure, metadata, and documentation. Use when building executable skills, markdown skills, or provider skills for the AtlasClaw AI Agent. - 90Create Claude Channel
Step-by-step procedure for building a Claude Code channel integration. Use when creating a new channel plugin that connects Claude Code to external systems via MCP, named pipes, webhooks, or chat platforms. - 100add-skill
Create new Claude Code skills with proper structure. Use when adding a skill or slash command. - 95write-a-skill
Create new agent skills with proper structure, progressive disclosure, and bundled resources. Use when user wants to create, write, or build a new skill. - 100write-a-skill
Create new agent skills with proper structure, progressive disclosure, and bundled resources. Use when user wants to create, write, or build a new skill. - 100write-a-skill
Create new agent skills with proper structure, progressive disclosure, and bundled resources. Use when user wants to create, write, or build a new skill.