Kibo.AgenticAdmin

Tool Management

Overview

Tools extend your agent’s capabilities by providing access to external systems, APIs, and custom functions. They enable agents to perform actions beyond simple conversation, such as searching databases, processing transactions, or integrating with third-party services.

Tool Types

1. Function Tools

Custom functions that execute specific logic.

Use Cases:

Example:

Name: Calculate Shipping Cost
Type: Function Tool
Description: Calculates shipping cost based on weight and destination
Input: { weight: number, destination: string }
Output: { cost: number, estimatedDays: number }

2. OpenAPI Tools

REST API integrations using OpenAPI specifications.

Use Cases:

Example:

Name: Product Catalog API
Type: OpenAPI Tool
Description: Access product inventory and details
Spec: OpenAPI 3.0 specification
Base URL: https://api.example.com/v1
Auth: Bearer token

3. Data Store Tools

Knowledge base and document search tools.

Use Cases:

Example:

Name: Customer Support Knowledge Base
Type: Data Store Tool
Description: Search support articles and documentation
Data Source: Support documentation database
Query Type: Natural language search

4. Extension Tools

Built-in tools provided by the platform.

Available Extensions:

Tool Configuration

Creating a Function Tool

  1. Navigate to Tools → Click “+ Create Tool”
  2. Select “Function Tool”
  3. Configure Basic Information:
    • Display Name
    • Description
    • Tool ID (auto-generated)
  4. Define Input Schema: 
    {
  "type": "object",
  "properties": {
 "productCode": {
   "type": "string",
   "description": "Product identifier"
 },
 "quantity": {
   "type": "integer",
   "description": "Number of items"
 }
  },
  "required": ["productCode", "quantity"]
}
  5. Define Output Schema: 
    {
  "type": "object",
  "properties": {
 "available": {
   "type": "boolean",
   "description": "Stock availability"
 },
 "message": {
   "type": "string",
   "description": "Availability message"
 }
  }
}

Creating an OpenAPI Tool

  1. Navigate to Tools → Click “+ Create Tool”
  2. Select “OpenAPI Tool”
  3. Provide OpenAPI Specification:
    • Paste full OpenAPI 3.0 spec
    • Or provide URL to spec file
  4. Configure Authentication:
    • API Key
    • Bearer Token
    • OAuth 2.0
    • Basic Auth
  5. Set Additional Options:
    • Base URL override
    • Custom headers
    • Timeout settings

Creating a Data Store Tool

  1. Navigate to Tools → Click “+ Create Tool”
  2. Select “Data Store Tool”
  3. Configure Data Source:
    • Connection string
    • Index/collection name
    • Authentication details
  4. Define Query Settings:
    • Search fields
    • Result limits
    • Ranking algorithm

Tool Management Interface

Tool List View

The tools page displays all configured tools with:

Tools List

┌─────────────────────────────────────┐
│ Tool Name                           │
│ Tool Type | Specification Type      │
│                                     │
│ [Edit] [Details] [Delete]          │
│                                     │
│ Description of what the tool does   │
│                                     │
│ Created: Date | Updated: Date       │
│ ID: unique-tool-identifier          │
└─────────────────────────────────────┘

Tool Details

Click “Details” to view:

Tool Details

Using Tools in Playbooks

Tool References

Reference tools in playbook instructions:

- Get product details
- Use ${TOOL:Product Search API} to find items
- Display results to user

Parameter Passing

Tools automatically receive parameters from conversation context:

- Ask user for product name
- Search using ${TOOL:Natural Language Search Tool}
  - The tool receives the product name automatically
- Show search results

Handling Tool Responses

- Call ${TOOL:Inventory Check Tool}
- If tool returns available=true:
  - Offer to add to cart
- If tool returns available=false:
  - Apologize and suggest alternatives

Advanced Tool Features

Tool Chaining

Execute multiple tools in sequence:

- ${TOOL:Get User Location}
- ${TOOL:Find Nearby Stores} using location
- ${TOOL:Check Store Inventory} for each store
- Present consolidated results

Conditional Tool Usage

- If user wants shipping info:
  - ${TOOL:Calculate Shipping}
- If user wants store pickup:
  - ${TOOL:Find Nearby Stores}

Error Handling

Built-in error handling for tool failures:

- Try ${TOOL:Payment Processing}
- If tool fails:
  - Inform user of issue
  - Offer alternative payment methods
  - Log error for support

Tool Performance

Monitoring

Track tool performance metrics:

Optimization

  1. Caching
    • Cache frequent queries
    • Set appropriate TTL
    • Invalidate stale data
  2. Timeouts
    • Set reasonable timeouts
    • Handle timeout gracefully
    • Provide fallback options
  3. Rate Limiting
    • Respect API limits
    • Implement throttling
    • Queue requests if needed

Security Considerations

Authentication

  1. API Keys
    • Store securely
    • Rotate regularly
    • Use environment variables
  2. OAuth Tokens
    • Implement refresh logic
    • Handle expiration
    • Secure token storage
  3. Permissions
    • Principle of least privilege
    • Audit tool access
    • Monitor usage patterns

Data Protection

  1. Sensitive Data
    • Don’t log sensitive information
    • Encrypt data in transit
    • Mask personal information
  2. Compliance
    • GDPR considerations
    • Data retention policies
    • Audit trails

Best Practices

Tool Design

  1. Single Purpose
    • Each tool should do one thing well
    • Avoid complex multi-function tools
    • Create composable tools
  2. Clear Naming
    • Descriptive tool names
    • Indicate function clearly
    • Use consistent conventions
  3. Comprehensive Documentation
    • Clear descriptions
    • Example inputs/outputs
    • Error scenarios

Testing

  1. Unit Testing
    • Test each tool independently
    • Verify all parameters
    • Check error handling
  2. Integration Testing
    • Test within playbooks
    • Verify tool chaining
    • Check real-world scenarios
  3. Load Testing
    • Test under high load
    • Verify performance
    • Check resource usage

Maintenance

  1. Version Control
    • Track tool changes
    • Document updates
    • Maintain compatibility
  2. Monitoring
    • Set up alerts
    • Track performance
    • Review error logs
  3. Updates
    • Regular dependency updates
    • Security patches
    • Feature enhancements

Common Tool Patterns

Search Tools

Input: { query: string, filters?: object }
Output: { results: array, count: number }

Transaction Tools

Input: { action: string, data: object }
Output: { success: boolean, id?: string, error?: string }

Validation Tools

Input: { data: object, rules: object }
Output: { valid: boolean, errors?: array }

Integration Tools

Input: { endpoint: string, method: string, body?: object }
Output: { status: number, data: object }

Troubleshooting

Common Issues

  1. Tool Not Found
    • Verify tool name in playbook
    • Check tool is active
    • Ensure proper permissions
  2. Authentication Failures
    • Verify credentials
    • Check token expiration
    • Review auth configuration
  3. Timeout Errors
    • Increase timeout setting
    • Check network connectivity
    • Verify endpoint availability
  4. Parameter Mismatches
    • Review schema definitions
    • Check parameter types
    • Validate required fields

Debug Strategies

  1. Enable Logging
    • Turn on verbose logging
    • Review request/response
    • Check error details
  2. Test in Isolation
    • Use tool test interface
    • Verify with sample data
    • Check edge cases
  3. Monitor Performance
    • Track response times
    • Identify bottlenecks
    • Optimize slow tools