Skip to main content

​
Tools Overview

Tools are the building blocks that give your agents the ability to interact with external systems, process data, and perform complex operations. PLai Framework supports 6 different tool types, each designed for specific use cases.

​
Available Tool Types

API Request

Make HTTP requests to any REST API with full configuration control Default

Perplexity AI

Web search and research capabilities powered by Perplexity AI Pro

MCP Server

Connect to Model Context Protocol servers for extended functionality Preview

Browser

Web scraping and browser automation with ScraperAPI integration Default

External Data Source

Connect to external databases and data sources Pro

Code Interpreter

Execute code in a secure sandboxed environment Alpha

​
Tool Status Levels

Understanding tool maturity helps you make informed decisions:
  • Production Ready: Thoroughly tested and stable
  • Full Support: Complete documentation and support
  • All Plans: Available on all subscription tiers
  • Examples: API Request, Browser Tools

​
Tool Categories

​
Communication Tools

Tools that enable agents to interact with external services and APIs:
Purpose: Connect to any REST API endpointKey Features:
  • Custom HTTP methods (GET, POST, PUT, DELETE)
  • Flexible header configuration
  • Request body templating
  • Response parsing and handling
Use Cases:
  • CRM integration (Salesforce, HubSpot)
  • Payment processing (Stripe, PayPal)
  • Notification services (Slack, Discord)
  • Custom internal APIs
Purpose: Web search and research capabilitiesKey Features:
  • Multiple model options (Sonar, Sonar Pro, Sonar Reasoning)
  • Domain-specific search filtering
  • Real-time web information
  • Citation and source tracking
Use Cases:
  • Market research
  • News and current events
  • Fact-checking
  • Competitive analysis

​
Processing Tools

Tools that enable data processing and code execution:
Purpose: Web scraping and browser automationKey Features:
  • ScraperAPI integration for reliable scraping
  • JavaScript rendering support
  • Beautiful Soup for HTML parsing
  • Rate limiting and proxy support
Use Cases:
  • Price monitoring
  • Content extraction
  • Website testing
  • Data collection
Purpose: Execute code in secure environmentsKey Features:
  • Multiple language support
  • Sandboxed execution
  • File system access
  • Output capture and formatting
Use Cases:
  • Data analysis
  • Mathematical calculations
  • Report generation
  • Algorithm implementation

​
Data Tools

Tools that provide access to external data sources:
Purpose: Connect to databases and data sourcesKey Features:
  • Multiple database support (SQL, NoSQL)
  • Secure connection management
  • Query optimization
  • Real-time data access
Use Cases:
  • Customer data lookup
  • Inventory management
  • Analytics and reporting
  • Data synchronization
Purpose: Model Context Protocol server integrationKey Features:
  • Standardized protocol support
  • OAuth and token authentication
  • Remote server connections
  • Extensible architecture
Use Cases:
  • Custom tool development
  • Enterprise integrations
  • Third-party service connections
  • Distributed architectures

​
Tool Configuration

​
General Configuration Process

All tools follow a similar configuration pattern:
1

Select Tool Type

Choose the appropriate tool type for your use case
2

Configure Parameters

Fill in required and optional configuration parameters
3

Test Connection

Verify the tool works correctly with test inputs
4

Add to Agent

Assign the tool to one or more agents
5

Monitor Usage

Track tool performance and usage through analytics

​
Common Configuration Options

Most tools share these configuration elements:
  • Name: Human-readable identifier for the tool
  • Description: Purpose and functionality summary
  • Authentication: API keys, tokens, or credentials
  • Rate Limits: Request throttling and usage controls
  • Error Handling: Retry logic and fallback options
  • Logging: Activity tracking and debugging info

​
Tool Security

​
Authentication Methods

API Keys

Simple key-based authentication for most APIs

OAuth 2.0

Secure token-based authentication for enterprise APIs

Basic Auth

Username/password authentication for legacy systems

​
Security Best Practices

Credential Security: Never expose API keys or credentials in tool descriptions or logs.
Environment Variables: Use environment variables or secure vaults for sensitive credentials.
  • Rotate Credentials: Regularly update API keys and access tokens
  • Minimal Permissions: Grant only necessary permissions to tools
  • Monitor Usage: Track tool usage for unusual activity
  • Audit Logs: Maintain logs of all tool interactions

​
Performance Optimization

​
Caching Strategies

Tools can implement various caching mechanisms:

​
Rate Limiting

Effective rate limiting strategies:
  • Tool-Level Limits: Per-tool rate limiting
  • Agent-Level Limits: Per-agent usage controls
  • Organization-Level Limits: Global usage caps
  • Dynamic Adjustment: Automatic limit adjustment based on usage

​
Troubleshooting

​
Common Issues

Symptoms: 401 or 403 errors, access denied messagesSolutions:
  • Verify API keys and credentials
  • Check permission scopes
  • Confirm rate limits haven’t been exceeded
  • Review authentication method configuration
Symptoms: Request timeout errors, slow responsesSolutions:
  • Check network connectivity
  • Increase timeout values
  • Implement retry logic
  • Use connection pooling
Symptoms: Parsing errors, unexpected responsesSolutions:
  • Validate request/response formats
  • Check API documentation
  • Update tool configuration
  • Implement proper error handling

​
Tool Development

​
Custom Tool Creation

While PLai Framework provides built-in tools, you can extend functionality:
  1. MCP Server Development: Create custom MCP servers for specialized functionality
  2. API Wrapper Tools: Build tools that interact with specific APIs
  3. Data Processing Tools: Develop tools for custom data transformations
  4. Integration Tools: Create tools for enterprise system integration

​
Tool Testing

Comprehensive testing ensures tool reliability: 
// Example tool test
describe('API Request Tool', () => {
  test('should make successful GET request', async () => {
    const tool = new APIRequestTool(config);
    const result = await tool.execute({
      method: 'GET',
      url: 'https://api.example.com/data'
    });
    
    expect(result.status).toBe(200);
    expect(result.data).toBeDefined();
  });
});

​
Next Steps

Create Your First Tool

Start with the API Request tool

Tool Configuration Guide

Learn advanced tool configuration

Browse All Tools

Explore all available tool types

MCP Development

Build custom MCP servers