Agentic Actions Across Integrations

When building an AI agent application, you’ll need to give the AI agent the ability to perform read, write, and update operations in your customers’ 3rd-party applications like CRMs, calendar apps, ticketing platforms, etc.

Paragon makes it easy to equip your AI agents with 3rd-party actions with ActionKit - a single API or MCP server to instantly give your AI agent hundreds of integration function tools.

ActionKit

With a single GET actions call, the ActionKit API exposes thousands of actions for popular integration providers like Google Drive, Calendar, Slack, Salesforce, and many more.

These actions can be given to your agents as tools, enabling them to perform actions like:

• Querying data from a CRM

• Sending messages via Slack and teams

• Updating tickets in platforms like Jira and Zendesk

Implementation:

ActionKit is designed to be easy to work with across LLM providers, frameworks, and protocols. In your implementation, you can give the tool data returned from the ActionKit API directly to your agent in the form of function tools.

Use the GET actions call to get tool descriptions and parameters for thousands of tools.

const actions = await fetch("<https://actionkit.useparagon.com/projects/><Project ID>/actions", {
	method: "GET",
	headers: {
		Authorization: `Bearer ${Paragon User Token}`
	}
});

The response will be a json schema with tool names, descriptions, and parameters that we’ve tested to optimize proper tool calling:

{
    "type": "function",
    "function": {
        "name": "GMAIL_SEND_EMAIL",
        "description": "Send an email in Gmail",
        "parameters": {
            "type": "object",
            "properties": {
                "toRecipients": {
                    "type": "array",
                    "description": "To : Specify the recipients as either a single string or a JSON array. (example: \\"[\\n  \\"recipient1@domain.com\\",\\n  \\"recipient2@domain.com\\"\\n]\\")",
                    "items": {
                        "type": "string"
                    }
                },
                ...
            },
            "required": [
                "toRecipients",
                "from",
                "subject",
                "messageContent"
            ],
            "additionalProperties": false
        }
    }
},
{
    "type": "function",
    "function": {
      "name": "GOOGLE_CALENDAR_LIST_EVENTS",
      "description": "Triggered when a user wants to lists event",
      "parameters": {
        "type": "object",
        "properties": {
          "calendar": {
            "type": "string",
            "description": "Calendar : Use Connect Portal Workflow Settings to allow users to select which calendar the event will be added to. Defaults to the user’s primary calendar if left blank."
          },
          "after": {
            "type": "string",
            "description": "After : Filters events that start after the provided date (Unix or ISO timestamp)."
          },
          "before": {
            "type": "string",
            "description": "Before : Filters events that end before the provided date (Unix or ISO timestamp)."
          }
        },
        "required": [],
        "additionalProperties": false

Easily plug in the tool metadata into LLM providers and frameworks like Vercel’s AI SDK, as shown below. ActionKit is LLM and framework agnostic where you can pass ActionKit into any LLM that supports function tools (see more examples such as a LangChain implementation).

import { generateText } from 'ai';
import { openai } from '@ai-sdk/openai';

await generateText({
	model: openai('gpt-4o'),
	tools: Object.values(await actions.json()).flat(),
	toolChoice: 'auto',
	temperature: 0,
	system: 'You are a helpful assistant. Be as concise as possible.',
	prompt: 'Help me create a new task in Jira.'
});

Once the ActionKit tools are loaded, your AI agent uses the descriptions and parameters from the GET actions to make decisions on when tools should be called. An agent then performs actions with a POST actions call to trigger the 3rd-party action, enabling your AI agent to build features like this with just a few lines of code!

In this example, the user asked the AI agent to send Salesforce Contact data in Slack. Our agent was able to call the SALESFORCE_WRITE_SOQL_QUERY to retrieve the contact details, followed by a SLACK_SEND_DIRECT_MESSAGES tool to send that Salesforce data via Slack with one message to the agent.

The ActionKit API was designed to be easily plugged in to any framework and LLM provider (as seen in the few lines of code above). However ActionKit can also be delivered through MCP, allowing MCP clients to instantly use the same tools the ActionKit API offers.

ActionKit MCP

The ActionKit MCP - a publicly listed 3rd-party server on the Anthropic MCP registry - is an MCP server using SSE transport to support multi-tenant MCP clients. To setup the ActionKit MCP server:

1. Just run the ActionKit MCP server

2. Point your MCP client to the server

3. The ActionKit Server will provide the same 3rd-party tools as the ActionKit API AND magic links for end-user authentication into the needed integrations

Whether your AI SaaS application wants agent tool calls delivered via API or MCP, ActionKit can deliver 3rd-party integration tools to your production-ready agents. Checkout our MCP repository to start running the ActionKit MCP server.

Wrapping Up

Use ActionKit to instantly give your AI agent access to thousands of tools across 3rd-party integrations.

• If you’re using the API, ActionKit easily slots in to any LLM provider or framework to expose and run tools.

• If your SaaS application is an MCP client, use the ActionKit MCP server to give your client ActionKit provided tools and magic links to authenticate users to their integrations when needed.

To learn more about how Paragon can enable your AI application to perform actions across integrations and our exciting new AI-focused features, book a demo to schedule some time with our team.