ActionKit for Tool Calling

ActionKit is designed to give AI agents the ability to call out to integration logic as a part of a prompt or ongoing conversation with a user. The API exposes JSON Schema specs to easily provide your agent with capabilities including:

Creating tasks in Jira based on action items an agent recognizes from a meeting transcript
Querying real-time sales reports in Shopify when an agent is asked questions about online sales
Creating a Google Docs draft to start a project based on a user prompt

Implementation Examples

Vercel AI SDK

Implementing ActionKit in AI SDK

import { generateText, jsonSchema, tool } from "ai";
import { openai } from "@ai-sdk/openai";

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

const { tools, errors } = await response.json();

if (errors.length === 0) {
  await generateText({
    model: openai("gpt-4o"),
    tools: Object.fromEntries(
      tools.map((tool) => [
        tool.function.name,
        tool({
          description: tool.function.description,
          parameters: jsonSchema(tool.function.parameters),
          execute: async (params: any, { toolCallId }) => {
            try {
              const response = await fetch(
                `https://actionkit.useparagon.com/projects/<Project ID>/tools`,
                {
                  method: "POST",
                  body: JSON.stringify({
                    tool: tool.function.name,
                    parameters: params,
                  }),
                  headers: {
                    Authorization: `Bearer ${session.paragonUserToken}`,
                    "Content-Type": "application/json",
                  },
                }
              );
              const output = await response.json();
              if (!response.ok) {
                throw new Error(JSON.stringify(output, null, 2));
              }
              return output;
            } catch (err) {
              if (err instanceof Error) {
                return { error: { message: err.message } };
              }
              return err;
            }
          },
        }),
      ])
    ),
    toolChoice: "auto",
    temperature: 0,
    system: "You are a helpful assistant. Be as concise as possible.",
    prompt: "Help me create a new task in Jira.",
  });
}

LangGraph / LangChain

Implementing ActionKit in LangChain

import json
import requests
from typing import Annotated, Any, TypedDict
from langchain.tools import BaseTool
from langchain.schema import HumanMessage
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from langgraph.prebuilt import ToolNode, tools_condition
from langchain_openai import ChatOpenAI

PARAGON_PROJECT_ID = ""
PARAGON_USER_TOKEN = ""
OPENAI_API_KEY = ""

class ActionKitTool(BaseTool):
    name: str
    description: str
    tool_name: str
    paragon_token: str

    def _run(self, tool_input: str) -> str:
        try:
            params = json.loads(tool_input)
            response = requests.post(
                url=f"https://actionkit.useparagon.com/projects/{PARAGON_PROJECT_ID}/tools",
                headers={
                    "Authorization": f"Bearer {self.paragon_token}",
                    "Content-Type": "application/json",
                },
                json={
                    "tool": self.tool_name,
                    "parameters": params,
                },
                timeout=30
            )
            data = response.json()

            if not response.ok:
                raise ValueError(json.dumps(data, indent=2))

            return json.dumps(data)
        except Exception as e:
            return json.dumps({"error": {"message": str(e)}})

class State(TypedDict):
    messages: Annotated[list, add_messages]

def main():
    graph_builder = StateGraph(State)
    url = f"https://actionkit.useparagon.com/projects/{PARAGON_PROJECT_ID}/tools"
    headers = {"Authorization": f"Bearer {PARAGON_USER_TOKEN}"}
    
    resp = requests.get(url, headers=headers)
    json_resp = resp.json()
    tools = json_resp.get("tools", [])
    errors = json_resp.get("errors", [])

    if not tools:
        print("Failed to fetch Paragon tools or encountered errors:")
        print(errors)
        return

    tools_list = []
    for integration in tools:
        integration_tools = tools.get(integration)
        for tool in integration_tools:
            func_def = tool["function"]
            tool_name = func_def["name"]
            tool_description = func_def["description"]

            paragon_tool = ActionKitTool(
                name=tool_name,
                description=tool_description,
                tool_name=tool_name,
                paragon_token=PARAGON_USER_TOKEN
            )
            tools_list.append(paragon_tool)

    llm = ChatOpenAI(
        openai_api_key=OPENAI_API_KEY,
        model_name="o1"
    )
    
    def chatbot(state: State):
        return {"messages": [llm.bind_tools(tools_list).invoke(state["messages"])]}
    
    graph_builder.add_node("chatbot", chatbot)
    tools_node = ToolNode(tools=tools_list)
    graph_builder.add_node("tools", tools_node)
    graph_builder.add_conditional_edges(
        "chatbot",
        tools_condition,
    )
    graph_builder.add_edge("tools", "chatbot")
    graph_builder.add_edge(START, "chatbot")

    graph = graph_builder.compile()

    def stream_graph_updates(user_input: str):
        for event in graph.stream({"messages": [{"role": "user", "content": user_input}]}):
            for value in event.values():
                print("Assistant:", value["messages"][-1].content)

    while True:
        try:
            user_input = input("User: ")
            if user_input.lower() in ["quit", "exit", "q"]:
                print("Goodbye!")
                break

            stream_graph_updates(user_input)
        except:
            # fallback if input() is not available
            user_input = "What do you know about LangGraph?"
            print("User: " + user_input)
            stream_graph_updates(user_input)
            break

if __name__ == "__main__":
    main()

Other implementations

If you’re not using TypeScript, you can pass the JSON Schema specs from the ActionKit to the request to your LLM. Here is an example in Python with OpenAI’s library:

Loading ActionKit tools for OpenAI client library

import requests
from openai import OpenAI
client = OpenAI()

actions_url = f"https://actionkit.useparagon.com/projects/{project_id}/tools"
actions_auth_header = {
	"Authorization": f"Bearer {user_token}"
}
get_tools_params = {
    "format": "json_schema",
    "categories": "crm,project_management"
}

response = requests.get(actions_url, params=get_tools_params, headers=actions_auth_header)
paragon_tools = response.json()

messages = [{"role": "user", "content": "Help me create a Jira ticket"}]
completion = client.chat.completions.create(
  model="gpt-4o",
  messages=messages,
  tools=paragon_tools["tools"],
  tool_choice="auto"
)

When passing the specs directly, you will also need to respond to the agent’s request to use a tool and route it to the ActionKit:

Calling ActionKit tools with OpenAI client library

message = completion["choices"][0]["message"]

if message.get("function_call"):
    function_name = message["function_call"]["name"]
    arguments = json.loads(message["function_call"]["arguments"])
    
    # Check if this tool uses ActionKit
    if any(tool["name"] == function_name for tool in paragon_tools["tools"]):
        run_tools_body = {
            "tool": function_name,
            "parameters": arguments
        }

        # Run Tool
        response = requests.post(actions_url, body=run_tools_body, headers=actions_auth_header)
        result = response.json()
        messages.append({
            "role": "function",
            "name": function_name,
            "content": json.dumps(result)
        })

        # Return to chat with tool result
        completion = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=paragon_tools,
            tool_choice="auto"
        )

Integration UI

Workflows

ActionKit for AI Agents

Implementation Examples

Vercel AI SDK

LangGraph / LangChain

Other implementations

​Implementation Examples

​Vercel AI SDK

​LangGraph / LangChain

​Other implementations

Implementation Examples

Vercel AI SDK

LangGraph / LangChain

Other implementations