Plugin Development

Creating Custom Tools

ReCloud supports extensibility through configuration files, allowing you to create custom tools without modifying core system code.

Configuration Framework

Each tool consists of configuration files that define the tool's interface and behavior:

Interface Configuration

The interface configuration defines the tool's public API and metadata visible to users:

name: customAnalyzer
pretty_name: Custom Text Analyzer
execution_target: remote
categories: ["analysis"]
description_short: "Advanced custom text analysis"
description_long: "Performs sophisticated analysis on text using custom algorithms and patterns"
parameters:
  - name: text
    type: string
    required: true
    description: "Text to analyze"
  - name: analysis_type
    type: string
    required: false
    description: "Type of analysis to perform"
    default: "general"
    options: ["general", "sentiment", "keywords", "entities"]
  - name: include_confidence
    type: boolean
    required: false
    description: "Include confidence scores"
    default: true
examples:
  - "Analyze this text for sentiment"
  - "Extract keywords from this article"

Configuration Fields:

name: Unique identifier
pretty_name: Human-readable name
execution_target: Processing location ("remote" or "local")
categories: Tool classification
parameters: Input specification with validation rules

Workflow Configuration

The workflow configuration defines the execution logic and processing steps:

name: customAnalyzer
execution_target: remote
model: "gemini-2.5-flash"
step_types:
  - name: "ai_analysis"
    handler: "ai_analysis"
    prompt_template: "Analyze this text: {{flow_input.text}} using {{flow_input.analysis_type}} method"
  - name: "confidence_scorer"
    handler: "confidence_scorer"
    enabled: "{{flow_input.include_confidence}}"
flow:
  - step: "perform_analysis"
    type: "ai_analysis"
  - step: "calculate_confidence"
    type: "confidence_scorer"
    depends_on: "perform_analysis"

Development Steps

1. Design the Tool Interface

Define what your tool will do and what inputs it needs:

Purpose: What problem does it solve?
Inputs: What data does it need?
Outputs: What results does it produce?
Execution Target: Should it run remotely (AI processing) or locally (system operations)?

2. Create Configuration Files

Create the interface and workflow configuration files following the examples above.

3. Test the Configuration

Validate your configuration files and test the tool execution:

# Test tool configuration
recloud tools validate customAnalyzer

# Test tool execution
recloud tools test customAnalyzer --text "Sample text"

4. Register the Tool

Add your tool to the system catalog:

# Register new tool
recloud tools register customAnalyzer

# Update tool catalog
recloud tools refresh

Tool Categories

AI-Powered Tools (Remote Execution)

Tools that leverage AI models for processing:

Text Analysis: Sentiment analysis, classification, summarization
Content Generation: Code generation, content creation, translation
Data Analysis: Pattern recognition, anomaly detection, forecasting

System Tools (Local Execution)

Tools that interact with the local system:

File Operations: Reading, writing, processing files
System Monitoring: Resource usage, performance metrics
Local Processing: Image processing, data formatting

Hybrid Tools

Tools that combine remote and local processing:

Data Processing: Fetch remote data, process locally
Content Enhancement: Generate content, format locally
Workflow Automation: Orchestrate multiple processing steps

Best Practices

Interface Design

Clear Naming: Use descriptive names that indicate functionality
Minimal Parameters: Keep the interface simple and focused
Default Values: Provide sensible defaults for optional parameters
Validation: Include parameter validation rules

Configuration

Modular Steps: Break complex workflows into smaller steps
Error Handling: Include error handling in workflow steps
Resource Management: Consider resource usage in configuration
Testing: Test configurations thoroughly before deployment

Performance

Execution Target: Choose appropriate execution environment
Caching: Implement caching for expensive operations
Batch Processing: Support batch operations where possible
Resource Limits: Define appropriate resource constraints

Examples

Simple Text Analysis Tool

name: keywordExtractor
pretty_name: Keyword Extractor
execution_target: remote
categories: ["analysis"]
description_short: "Extract important keywords from text"
parameters:
  - name: text
    type: string
    required: true
    description: "Text to analyze"
  - name: max_keywords
    type: number
    required: false
    description: "Maximum number of keywords to extract"
    default: 10

Local File Processing Tool

name: fileSummarizer
pretty_name: File Summarizer
execution_target: local
categories: ["file-processing"]
description_short: "Generate summary of file contents"
parameters:
  - name: file_path
    type: string
    required: true
    description: "Path to file to summarize"
  - name: summary_length
    type: string
    required: false
    description: "Summary length"
    default: "short"
    options: ["short", "medium", "long"]

Troubleshooting

Common Issues

Configuration Errors: Validate configuration syntax
Parameter Validation: Check parameter types and requirements
Execution Failures: Review error logs and step dependencies
Performance Issues: Monitor resource usage and execution times

Debugging Tools

Configuration Validator: Check configuration file syntax
Execution Tracer: Track step-by-step execution
Performance Monitor: Analyze resource usage patterns
Error Reporter: Detailed error information and stack traces

Plugin development allows you to extend ReCloud's capabilities by creating custom tools that integrate seamlessly with the existing ecosystem.