Skip to main content
xpander provides two ways to add capabilities to your agents:

Tools

APIs exposed as function calling with advanced filtering, authentication, and Agentic RAG

MCP Servers

Connect to Model Context Protocol servers for standardized tool integration

​
Tools

Tools are APIs that xpander exposes to your agents as function calling capabilities. Your agent can invoke these functions during conversations to access external data and services.

​
Pre-built Tools Library

Browse and select from hundreds of pre-built tools in the Workbench, covering popular SaaS platforms like GitHub, Google Workspace, Jira, Asana, Notion, and more.

Ready to Use

No configuration required, just select and enable

Production-tested

Built and maintained by the xpander connector generator agent

Regularly Updated

Keep pace with API changes and new features
You can also generate your own tools by providing an OpenAPI/Swagger specification. This allows you to create private tools for your internal APIs or custom home-grown services.

​
Custom Tools with SDK

Register your own functions directly in your agent’s code using the @register_tool decorator for complete control over tool behavior and integration. 
from xpander_sdk import Backend, register_tool
from agno.agent import Agent

@register_tool
def weather_check(location: str) -> str:
    """Check weather for a location"""
    return f"Weather in {location}: Sunny, 25°C"

backend = Backend()
agno_agent = Agent(**backend.get_args())
agno_agent.print_response(message="What's the weather in SFO?")
The agent has access to both pre-built tools (configured in the Workbench) and your custom tools. The agno_agent.tools property contains all available functions, seamlessly combining cloud-managed tools with your local custom tools.

​
Advanced Tool Capabilities

Each tool in the Workbench can be configured with powerful optimization features. Click the Settings button next to any tool to access:

Scheme Editor

Edit input and output schemas to customize tool behavior

Agentic RAG

Semantic querying for large payloads before loading into memory

Filtering & PII

Cherry-pick fields and remove sensitive data
Key capabilities:
  • Input Schema - Hard-code parameters, set defaults, or restrict what the agent can control
  • Output Schema - Filter response fields, remove PII, reduce token usage
  • Agentic RAG - When APIs return large datasets (1M records), agents can semantically query and retrieve only relevant items before loading into memory
See the Tool Scheme Advanced Tab section below for detailed configuration options.

​
Authentication

​
Authentication Methods

API Keys

Token-based authentication

OAuth 2.0

Delegated access with user consent

AWS IAM Roles

Temporary cross-account credentials

​
Authentication Modes

  • Integration User - Shared credentials for all agents
  • End-User - Individual user authentication (Slack agents only)
  • No Authentication - For public connectors

​
API Key Authentication

​
Configuration

  1. Go to Connectors → select your connector
  2. Click Other auth options
  3. Enter a connector name
  4. Select Integration User mode
  5. Choose API Key method
  6. Enter your API key
  7. Select Auth Type:
    • Bearer - Authorization: Bearer {token}
    • Basic - Base64 encoded credentials
    • Custom - Define your own header
  8. Save
API Key Configuration

​
OAuth 2.0 Authentication

  1. Go to Connectors → select your connector
  2. Click Sign in with
  3. Grant permissions
  4. Done
xpander manages tokens and handles refresh automatically.
OAuth Flow

​
AWS Cross-Account IAM Roles

Use IAM roles to grant xpander temporary access to AWS services (S3, CloudWatch, Lambda, etc.) without sharing long-term credentials.

​
Setup (CLI)

Replace <YOUR_ACCOUNT_ID> with your AWS account ID:
1. Create the Trust Policy
cat > trust-policy.json <<'EOF'
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::211125312782:role/api-caller-sa"
      },
      "Action": "sts:AssumeRole",
      "Condition": {
        "StringEquals": {
          "sts:ExternalId": "cca29b9b-f718-43a3-8802-84e812a019e1"
        }
      }
    }
  ]
}
EOF
The external ID prevents the confused deputy problem. Always use this exact value.
2. Create the IAM Role
aws iam create-role \
  --role-name xpanderAccessRole \
  --assume-role-policy-document file://trust-policy.json \
  --description "Grants xpander cross-account access to AWS services"
3. Add Permissions
cat > xpander-access-policy.json <<'EOF'
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:ListBucket",
        "cloudwatch:GetMetricStatistics",
        "lambda:GetFunction",
        "logs:GetLogEvents"
      ],
      "Resource": "*"
    }
  ]
}
EOF

aws iam put-role-policy \
  --role-name xpanderAccessRole \
  --policy-name xpanderAccessPolicy \
  --policy-document file://xpander-access-policy.json
In production, restrict Resource to specific ARNs: "Resource": ["arn:aws:s3:::my-bucket/*"]
4. Get Role ARN
aws iam get-role --role-name xpanderAccessRole --query "Role.Arn" --output text
Output: arn:aws:iam::<YOUR_ACCOUNT_ID>:role/xpanderAccessRole
5. Connect in xpander
  1. Go to Connections → Add new → AWS
  2. Choose Assume Role
  3. Paste Role ARN
  4. Save
AWS IAM Role Configuration

​
Common Permission Policies

{
  "Effect": "Allow",
  "Action": ["s3:GetObject", "s3:PutObject", "s3:ListBucket"],
  "Resource": ["arn:aws:s3:::my-bucket", "arn:aws:s3:::my-bucket/*"]
}

{
  "Effect": "Allow",
  "Action": ["logs:DescribeLogGroups", "logs:GetLogEvents"],
  "Resource": "arn:aws:logs:*:*:log-group:/aws/*"
}

{
  "Effect": "Allow",
  "Action": ["lambda:InvokeFunction", "lambda:GetFunction"],
  "Resource": "arn:aws:lambda:*:*:function:*"
}

​
MCP (Model Context Protocol)

In addition to Tools, you can connect your agents to MCP servers to provide additional capabilities. MCP servers are a standardized way to expose tools and resources using the Model Context Protocol.

Remote MCPs

Connect to MCP servers hosted externally - in your infrastructure or by SaaS providers

Local MCPs

Run MCP servers directly alongside your agent in the xpander cloud environment

​
Remote MCPs

Use remote MCPs to connect your agent to an MCP server hosted externally. How it works:
  1. Provide a URL to a running MCP server
  2. Select which tools from the MCP server to attach to your agent
  3. xpander connects to it at runtime and makes the tools available to your agent

​
Local MCPs

Use local MCPs to run an MCP server process directly alongside your agent. How it works:
  1. Define the command that runs the MCP server process
  2. xpander launches it as part of the agent’s lifecycle
  3. The server runs in the xpander cloud environment
  4. Tools from the MCP server are automatically available to your agent
To create and manage MCP servers, compose tools from multiple connectors, or use agents as MCP servers, see the MCP Task Source documentation.

​
Tool Dependencies

Tool dependencies control the execution order of your agent’s tools. When you set a dependency, Tool B will only run after Tool A completes successfully, while Tool A can still run independently. This is useful for workflows where one tool needs data from another or if you want to make sure a tool never runs before a different tool is invoked. How to set dependencies:
  1. Click the top connection point of the tool that must wait (Tool B)
  2. Drag the line to the bottom connection point of the tool it depends on (Tool A)
  3. The dependency will be created automatically
You can add multiple dependencies to a single tool, creating complex workflow chains. In the following example, we set the Send Email tool to only be available after the Calendly Get Availability Schedule tool is called.
alt text

​
Tool Scheme Advanced Tab

Individual tool details and configurations are available in the Workbench by clicking the Settings button next to each tool.
  • Details
  • Instructions
  • Input Schema
  • Output Schema
  • Advanced (Agentic RAG)
The Details tab shows the original, generated function calling description that defines the tool’s purpose and behavior. This serves as a reference for the tool’s intended use.
Tool Details Tab
This information is especially useful when you’re working with multiple similar tools and need to understand the exact purpose of each one.
⌘I