Tools

Create and register custom tools with the ISA MCP platform.

Overview

The platform includes 88+ built-in tools organized by category, with automatic discovery for custom tools.

Tool Categories

Creating Custom Tools

Step 1: Create Tool File

Create a file ending with _tools.py in the tools/ directory:

# tools/my_custom_tools.py
from datetime import datetime
from typing import Dict, Any, Optional
from mcp.server.fastmcp import FastMCP
 
def register_my_custom_tools(mcp: FastMCP):
    """Register custom tools with MCP server."""
 
    @mcp.tool()
    async def my_custom_tool(
        param1: str,
        param2: Optional[int] = None
    ) -> Dict[str, Any]:
        """
        My custom tool description.
 
        Detailed explanation of what this tool does and when to use it.
 
        Args:
            param1: Description of param1
            param2: Optional description of param2
 
        Returns:
            {"result": "...", "status": "success"}
 
        Keywords: custom, example, demo
        """
        result = f"Processed: {param1}"
        if param2:
            result += f" with value {param2}"
 
        return {
            "result": result,
            "status": "success",
            "timestamp": datetime.now().isoformat()
        }
 
    print("Custom tools registered")

Step 2: File Naming Convention

The auto-discovery system requires:

1. Filename: Must end with _tools.py
2. Register function: Must be named register_{filename}(mcp)

Examples:

• weather_tools.py → register_weather_tools(mcp)
• analytics_tools.py → register_analytics_tools(mcp)

Step 3: Location

Place your tool file in:

• tools/ (root level)
• tools/{category}/ (any subdirectory)

Using BaseTool Class

For advanced tools with ISA integration:

from tools.base_tool import BaseTool
from mcp.server.fastmcp import Context
 
class WeatherTool(BaseTool):
    def __init__(self):
        super().__init__()
 
    def register_tools(self, mcp):
        self.register_tool(
            mcp,
            self.get_weather,
            name="get_weather",
            description="Get weather for a location"
        )
 
    async def get_weather(
        self,
        location: str,
        ctx: Context = None
    ) -> Dict[str, Any]:
        # Report progress
        if ctx:
            await ctx.report_progress(0.5, "Fetching weather...")
 
        # Implementation
        return {"location": location, "temperature": 72}
 
def register_weather_tools(mcp):
    tool = WeatherTool()
    tool.register_tools(mcp)

BaseTool Features

Tool Annotations

@mcp.tool(
    name="custom_name",           # Override function name
    description="...",            # Override docstring
    annotations=ToolAnnotations(
        readOnlyHint=True,        # Tool doesn't modify state
        destructiveHint=False,    # Tool is safe
        idempotentHint=True       # Safe to retry
    )
)
async def my_tool():
    pass

Best Practices

1. Descriptive docstrings - Include keywords for semantic search
2. Type hints - Use for all parameters and return values
3. Error handling - Return structured error responses
4. Logging - Log important operations
5. Context parameter - Accept optional ctx: Context for MCP features

Auto-Discovery Process

1. Server scans tools/ directory recursively
2. Finds all *_tools.py files
3. Imports each module
4. Calls register_{module_name}(mcp) function
5. Logs success/failure for each module

Built-in Capability Highlights (2026-07)

A few built-in tools shipped or were fixed recently and are worth calling out beyond the category table above:

Image Generation

The agent can generate images directly from a chat request (e.g. “generate an image of a mountain lake at sunset”). Generation typically completes in ~13 seconds and returns an image the client renders inline in the conversation.

Office / Document Download

The agent can produce and hand back downloadable documents — PDF and PowerPoint (.pptx) are both supported. Generated files are uploaded to object storage and served back to the user via a signed download_url, so large documents don’t need to round-trip through the chat transport.

Date-Grounding

Every agent turn is injected with the actual current date and time before reasoning starts. This means relative-date phrasing in a request — “remind me tomorrow,” “what’s due this week” — resolves against the real current date rather than a stale or cached one.

Image-by-URL Input

The agent accepts an image URL as input, not just uploaded file attachments. It downloads the image (using a browser-like User-Agent header, since some hosts reject default HTTP client agents) and treats it as image input for the turn.

Next Steps

• Prompts - Create custom prompts
• Resources - Create custom resources
• Skills - Skill-based classification