Create Tools

Tools give models the ability to take action: call an API, run code, call an MCP, or invoke any external service. Tools require a model with function calling support, look for the tools tag in the AI Gateway. The following Tools are available:

Function Tool

Pass the tool call back to the caller for local execution. Define parameters with JSON Schema.

JSON Schema Tool

Enforce structured output from the model using a full JSON Schema definition.

HTTP Tool

Make a real HTTP request to an external API at runtime. No extra code needed.

MCP Tool

Connect to a Model Context Protocol server. Orq.ai discovers available capabilities automatically.

Python Tool

Run arbitrary Python code at runtime. Define logic and parameters directly in the Studio.

Choosing a tool type

Orq.ai executes every tool type except Function: the model calls the tool, the platform runs it, and the run continues without the application being involved. A Function Tool is the one that gets handed back. The platform returns the call and waits for the application to execute it and send the result, which makes it the escape hatch for anything the platform cannot reach on its own. Pick a Function Tool when the code needs the application’s own environment: a database connection, an internal client library, credentials that never leave the application, or logic that no single request can express. An HTTP Tool is less work when the capability is already a REST endpoint, because Orq.ai makes the request. An MCP Tool removes the schema work entirely for anything already behind a Model Context Protocol server. Small self-contained logic can go in a Python Tool, which runs on the platform with no application code at all.

Function Tool

A Function Tool lets the model call custom code that runs in the application invoking the agent, not on the Orq.ai platform. Use it for database queries, internal APIs, or any logic that requires access to the application’s environment. The worked example below runs the whole flow end to end, and Use Tools documents the request and response shapes field by field. The name refers to how the tool is defined, a function signature described with JSON Schema, and not to function calling in general. Every tool type on this page is exposed to the model through function calling. Only this one is executed by the caller.

AI Studio
API & SDK
CLI

Define a callable function using JSON Schema.

Add a new Tool to a Project

Use the button to add a new Entity to a Project.

Enter Tool Details

Enter the main details of the tool:

Key, used by models to reference the tool
Name, used in the studio to find the tool
Description, used to describe the tool
Make the Description as precise as possible, it is used notably by Agents when looking up relevant tools for their tasks.

Function Tool Configure — Configure all fields

Configure your Function Tool

Function Tools are defined using JSON.Here is an example of a JSON schema for a function get_current_weather that declares the fields location (string) and unit (string):

{
  "type": "object",
  "properties": {
    "unit": {
      "type": "string",
      "description": "The temperature unit, e.g. Celsius"
    },
    "location": {
      "type": "string",
      "description": "The city and state, e.g. San Francisco, CA"
    }
  },
  "required": [
    "location",
    "unit"
  ]
}

The object defined here is based on JSON Schema. This framework allows for extensible definition that fits your ideal function definition.

TypeUse here any of the valid JSON types: object, string, integer, number, array, etc. The top-level type will most commonly be an object holding other properties.Learn more about all JSON types in the JSON Schema definition.PropertiesProperties are definitions of fields within an object. Here you can define any new variable. Nested properties are allowed.RequiredThe required array within an object defines which fields must be entered for a JSON payload to be validated.

Publish your Tool

Once your tool is configured, click Publish to save a new version. Each published version is immutable and tracked in the version history.

A Function Tool defines a callable function using a JSON Schema parameter definition. The caller executes the function locally and returns the result to the model.

Field	Required	Description
`key`	Yes	Unique identifier (alphanumeric, hyphens, underscores)
`path`	Yes	Project path, e.g. `"Default"`
`type`	Yes	Must be `"function"`
`description`	Yes	Used by agents to decide when and how to call the tool
`display_name`	No	Human-readable name shown in the Studio
`function.name`	Yes	Function name
`function.parameters`	Yes	JSON Schema object describing the function parameters

curl -X POST https://my.orq.ai/v2/tools \
  -H "Authorization: Bearer $ORQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "key": "get_weather",
    "display_name": "Get Weather",
    "description": "Returns the current weather for a given city",
    "path": "Default",
    "type": "function",
    "function": {
      "name": "get_weather",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {
            "type": "string",
            "description": "The city name, e.g. Amsterdam"
          },
          "unit": {
            "type": "string",
            "description": "Temperature unit: celsius or fahrenheit"
          }
        },
        "required": ["location"]
      }
    }
  }'

from orq_ai_sdk import Orq
import os

orq = Orq(api_key=os.environ["ORQ_API_KEY"])

tool = orq.tools.create(request={
    "key": "get_weather",
    "display_name": "Get Weather",
    "description": "Returns the current weather for a given city",
    "path": "Default",
    "type": "function",
    "function": {
        "name": "get_weather",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The city name, e.g. Amsterdam",
                },
                "unit": {
                    "type": "string",
                    "description": "Temperature unit: celsius or fahrenheit",
                },
            },
            "required": ["location"],
        },
    },
})

import { Orq } from "@orq-ai/node";

const orq = new Orq({ apiKey: process.env["ORQ_API_KEY"] ?? "" });

const tool = await orq.tools.create({
  key: "get_weather",
  displayName: "Get Weather",
  description: "Returns the current weather for a given city",
  path: "Default",
  type: "function",
  function: {
    name: "get_weather",
    parameters: {
      type: "object",
      properties: {
        location: {
          type: "string",
          description: "The city name, e.g. Amsterdam",
        },
        unit: {
          type: "string",
          description: "Temperature unit: celsius or fahrenheit",
        },
      },
      required: ["location"],
    },
  },
});

See the full Create Tool API reference.

orq tools create \
  --key get_weather \
  --display-name "Get Weather" \
  --description "Returns the current weather for a given city" \
  --path Default \
  --type function \
  --function '{"name": "get_weather", "parameters": {"type": "object", "properties": {"location": {"type": "string", "description": "The city name, e.g. Amsterdam"}, "unit": {"type": "string", "description": "Temperature unit: celsius or fahrenheit"}}, "required": ["location"]}}'

See install and setup to get started with the CLI. Run orq tools create --help for the full flag reference.

Worked example: an Agent that checks stock

A support Agent answers stock questions against an internal inventory database. The database is only reachable from the application, which is what makes this a Function Tool rather than an HTTP Tool.

Write the tool definition

The description is the only thing the model reads when deciding whether to call the tool, so it states what the tool returns and when it applies, not just what it is. The parameter descriptions do the same job for the values.

{
  "key": "check_inventory",
  "type": "function",
  "path": "Default",
  "display_name": "Check Inventory",
  "description": "Checks live stock levels for specific SKUs. Returns the available quantity per stocked SKU, the SKUs that exist but are out of stock, and the SKUs that are not in the catalog at all. Call this before confirming availability or a delivery date to a customer, and call it again rather than reusing a quantity from earlier in the conversation.",
  "function": {
    "name": "check_inventory",
    "parameters": {
      "type": "object",
      "properties": {
        "skus": {
          "type": "array",
          "items": { "type": "string" },
          "description": "Catalog SKUs to look up, for example SKU-1180. Pass every SKU in one call instead of one call per SKU."
        }
      },
      "required": ["skus"],
      "additionalProperties": false
    }
  }
}

The warehouse is deliberately absent from the schema. The application reads it from the signed-in session and passes it in when it executes the call, so the model can neither see it nor choose it.

Attach the tool to the Agent

An Agent takes its tools from its own configuration, so Orq.ai ignores a tools array in the request. Attach the tool from the Agent configuration in Studio, or by key through the API. See Function Tools.

cURL

curl -X PATCH https://my.orq.ai/v2/agents/$AGENT_ID \
  -H "Authorization: Bearer $ORQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"settings": {"tools": [{"type": "function", "key": "check_inventory"}]}}'

Send the request

curl -X POST https://my.orq.ai/v3/router/responses \
  -H "Authorization: Bearer $ORQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "agent/support-agent",
    "input": "Can we ship SKU-1180 and SKU-9042 this week?"
  }'

from orq_ai_sdk import Orq
import os

orq = Orq(api_key=os.environ["ORQ_API_KEY"])

response = orq.responses.create(
    model="agent/support-agent",
    input="Can we ship SKU-1180 and SKU-9042 this week?",
)

import { Orq } from "@orq-ai/node";

const orq = new Orq({ apiKey: process.env.ORQ_API_KEY });

let response = await orq.responses.create({
  model: "agent/support-agent",
  input: "Can we ship SKU-1180 and SKU-9042 this week?",
});

The let declaration matters in TypeScript: the loop in the next step reassigns response.The model answers with a function_call output item instead of text. See Use Tools for the exact item shape.

Run the tool loop

A single response can contain more than one function_call item, and the model can call tools again after seeing the results. Execute every call in the response, send all the outputs back in one continuation request, and repeat until the response contains no function_call items.inventory_db and session below are the application’s own database client and request session, not part of the SDK.

import json

def check_inventory(arguments, warehouse_id):
    rows = inventory_db.lookup(warehouse_id, arguments["skus"])
    return {
        "in_stock": {row.sku: row.quantity for row in rows if row.quantity > 0},
        "out_of_stock": [row.sku for row in rows if row.quantity == 0],
        "unknown_skus": sorted(set(arguments["skus"]) - {row.sku for row in rows}),
    }

TOOL_HANDLERS = {"check_inventory": check_inventory}

def run_tool(call, warehouse_id):
    handler = TOOL_HANDLERS.get(call["name"])
    if handler is None:
        return {"error": f"Unknown tool {call['name']}."}
    try:
        arguments = json.loads(call["arguments"])
    except json.JSONDecodeError:
        return {"error": "Arguments were not valid JSON. Retry with valid JSON."}
    return handler(arguments, warehouse_id)

while True:
    function_calls = [item for item in response.output if item["type"] == "function_call"]
    if not function_calls:
        break

    outputs = [
        {
            "type": "function_call_output",
            "call_id": call["call_id"],
            "output": json.dumps(run_tool(call, session.warehouse_id)),
        }
        for call in function_calls
    ]

    response = orq.responses.create(
        model="agent/support-agent",
        previous_response_id=response.id,
        input=outputs,
    )

print(response.output[0]["content"][0]["text"])

const toolHandlers = {
  check_inventory: async (args, warehouseId) => {
    const rows = await inventoryDb.lookup(warehouseId, args.skus);
    return {
      in_stock: Object.fromEntries(rows.filter((r) => r.quantity > 0).map((r) => [r.sku, r.quantity])),
      out_of_stock: rows.filter((r) => r.quantity === 0).map((r) => r.sku),
      unknown_skus: args.skus.filter((sku) => !rows.some((r) => r.sku === sku)),
    };
  },
};

async function runTool(call, warehouseId) {
  const handler = toolHandlers[call.name];
  if (!handler) return { error: `Unknown tool ${call.name}.` };
  try {
    return await handler(JSON.parse(call.arguments), warehouseId);
  } catch {
    return { error: "Arguments were not valid JSON. Retry with valid JSON." };
  }
}

while ("output" in response) {
  const functionCalls = (response.output ?? []).filter(
    (item) => item.type === "function_call",
  ) as unknown as Array<{ name: string; arguments: string; call_id: string }>;
  if (functionCalls.length === 0) break;

  const outputs = await Promise.all(
    functionCalls.map(async (call) => ({
      type: "function_call_output" as const,
      callId: call.call_id,
      output: JSON.stringify(await runTool(call, session.warehouseId)),
    })),
  );

  response = await orq.responses.create({
    model: "agent/support-agent",
    previousResponseId: response.id,
    input: outputs,
  });
}

if ("output" in response) console.log(response.output?.[0]?.content?.[0]?.text);

The result shape matters as much as the description. Splitting out_of_stock from unknown_skus tells the model the difference between a real SKU with no stock, which is an answer, and a SKU it invented, which is a signal to look the product up again instead of reporting it as unavailable.

In production:

Validate arguments against the schema before execution. The model can send values that do not fit, and a malformed arguments string is a tool error to report back, not an exception that ends the run.
Keep tenant, account, and user identifiers out of the schema and supply them from the session, so the model cannot send the wrong one.
Return tool errors as a function_call_output describing the failure so the model can recover. Reserve raised exceptions for failures the model cannot act on.
Cap the number of rounds so a model that keeps calling tools cannot loop indefinitely.

To run the same loop against a model instead of an Agent, reference the saved schema with {"type": "orq:function", "tool_id": "..."} in the request tools array and repeat that array on every continuation request. Tool Calling covers the model-level patterns in depth, including parallel execution and retries.

JSON Schema Tool

AI Studio
API & SDK
CLI

Enforce structured output from the model using a full JSON Schema definition.

Add a new Tool to a Project

Use the button to add a new Entity to a Project.

Enter Tool Details

Enter the main details of the tool:

Key, used by models to reference the tool
Name, used in the studio to find the tool
Description, used to describe the tool
Make the Description as precise as possible, it is used notably by Agents when looking up relevant tools for their tasks.

JSON Schema Tool configure — Configure all fields

Configure your JSON Schema Tool

JSON Schema Tools are defined using JSON.Here is an example of a JSON schema for a function get_current_weather that declares the fields location (string) and unit (string):

{
  "type": "object",
  "properties": {
    "unit": {
      "type": "string",
      "description": "The temperature unit, e.g. Celsius"
    },
    "location": {
      "type": "string",
      "description": "The city and state, e.g. San Francisco, CA"
    }
  },
  "required": [
    "location",
    "unit"
  ]
}

The object defined here is based on JSON Schema. This framework allows for extensible definition that fits your ideal function definition.

Publish your Tool

Once your tool is configured, click Publish to save a new version. Each published version is immutable and tracked in the version history.

A JSON Schema Tool enforces structured output from the model using a full JSON Schema definition. Unlike Function Tools, the schema is defined at the top level with a name and description.

Field	Required	Description
`key`	Yes	Unique identifier (alphanumeric, hyphens, underscores)
`path`	Yes	Project path, e.g. `"Default"`
`type`	Yes	Must be `"json_schema"`
`description`	Yes	Used by agents to decide when and how to call the tool
`display_name`	No	Human-readable name shown in the Studio
`json_schema.name`	Yes	Schema name
`json_schema.description`	No	Describes the schema’s purpose
`json_schema.schema`	Yes	JSON Schema object enforcing the output structure

curl -X POST https://my.orq.ai/v2/tools \
  -H "Authorization: Bearer $ORQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "key": "extract_contact",
    "display_name": "Extract Contact",
    "description": "Extracts contact information from unstructured text",
    "path": "Default",
    "type": "json_schema",
    "json_schema": {
      "name": "extract_contact",
      "description": "Extracts name, email, and phone from text",
      "schema": {
        "type": "object",
        "properties": {
          "name": { "type": "string" },
          "email": { "type": "string" },
          "phone": { "type": "string" }
        },
        "required": ["name"]
      }
    }
  }'

from orq_ai_sdk import Orq
import os

orq = Orq(api_key=os.environ["ORQ_API_KEY"])

tool = orq.tools.create(request={
    "key": "extract_contact",
    "display_name": "Extract Contact",
    "description": "Extracts contact information from unstructured text",
    "path": "Default",
    "type": "json_schema",
    "json_schema": {
        "name": "extract_contact",
        "description": "Extracts name, email, and phone from text",
        "schema": {
            "type": "object",
            "properties": {
                "name": {"type": "string"},
                "email": {"type": "string"},
                "phone": {"type": "string"},
            },
            "required": ["name"],
        },
    },
})

import { Orq } from "@orq-ai/node";

const orq = new Orq({ apiKey: process.env["ORQ_API_KEY"] ?? "" });

const tool = await orq.tools.create({
  key: "extract_contact",
  displayName: "Extract Contact",
  description: "Extracts contact information from unstructured text",
  path: "Default",
  type: "json_schema",
  jsonSchema: {
    name: "extract_contact",
    description: "Extracts name, email, and phone from text",
    schema: {
      type: "object",
      properties: {
        name: { type: "string" },
        email: { type: "string" },
        phone: { type: "string" },
      },
      required: ["name"],
    },
  },
});

See the full Create Tool API reference.

Pipe the body via --stdin for tool types other than function; per-field flags currently validate --type against function only.

echo '{
  "key": "extract_contact",
  "display_name": "Extract Contact",
  "description": "Extracts contact information from unstructured text",
  "path": "Default",
  "type": "json_schema",
  "json_schema": {
    "name": "extract_contact",
    "description": "Extracts name, email, and phone from text",
    "schema": {
      "type": "object",
      "properties": {
        "name": { "type": "string" },
        "email": { "type": "string" },
        "phone": { "type": "string" }
      },
      "required": ["name"]
    }
  }
}' | orq tools create --stdin

See install and setup to get started with the CLI. Run orq tools create --help for the full flag reference.

HTTP Tool

AI Studio
API & SDK
CLI

Make a real HTTP request to an external API at runtime. Use {{variable}} syntax to inject dynamic values into any field.

Add a new Tool to a Project

Use the button to add a new Entity to a Project.

Enter Tool Details

Enter the main details of the tool:

Key, used by models to reference the tool
Name, used in the studio to find the tool
Description, used to describe the tool
Make the Description as precise as possible, it is used notably by Agents when looking up relevant tools for their tasks.

Configure your HTTP Tool

HTTP Tools are defined within the Studio, either using the UI or using JSON (use the toggle to change mode).

Http Tool Configuration Pn — Configure your HTTP Tool

Field	Description
URL	Enter the API URL as well as the HTTP Method for the call
Header	Define Request Header Key-value pairs
Payload	Define Request Body Payload Key-value pairs (these are translated to JSON at runtime)
Authentication	Define an optional Bearer Authentication field and Token (Tokens are encrypted when saved in Orq).

You can use Variables with the {{variable}} syntax within any configuration field. The variable will be resolved at runtime when the payload is built for the HTTP call.

Use the Autogenerate Schema when using variables to ensure variable definition is correctly created.

Publish your Tool

Once your tool is configured, click Publish to save a new version. Each published version is immutable and tracked in the version history.

An HTTP Tool makes a real HTTP request to an external API at runtime. Use {{variable}} syntax in any field to inject dynamic values.

Field	Required	Description
`key`	Yes	Unique identifier (alphanumeric, hyphens, underscores)
`path`	Yes	Project path, e.g. `"Default"`
`type`	Yes	Must be `"http"`
`description`	Yes	Used by agents to decide when and how to call the tool
`display_name`	No	Human-readable name shown in the Studio
`http.blueprint.url`	Yes	Target URL. Supports `{{variable}}` syntax
`http.blueprint.method`	Yes	HTTP method: `GET`, `POST`, `PUT`, `PATCH`, `DELETE`
`http.blueprint.headers`	No	Key-value pairs sent with every request
`http.blueprint.timeout`	No	Request timeout in seconds, 1 to 600. Defaults to 60
`http.blueprint.arguments`	No	Parameters the model can fill in at call time

curl -X POST https://my.orq.ai/v2/tools \
  -H "Authorization: Bearer $ORQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "key": "search_products",
    "display_name": "Search Products",
    "description": "Searches the product catalog by keyword",
    "path": "Default",
    "type": "http",
    "http": {
      "blueprint": {
        "url": "https://api.example.com/products/search",
        "method": "GET",
        "headers": {
          "Accept": "application/json"
        },
        "timeout": 30
      },
      "arguments": {
        "query": {
          "type": "string",
          "description": "Search keyword",
          "send_to_model": true
        }
      }
    }
  }'

from orq_ai_sdk import Orq
import os

orq = Orq(api_key=os.environ["ORQ_API_KEY"])

tool = orq.tools.create(request={
    "key": "search_products",
    "display_name": "Search Products",
    "description": "Searches the product catalog by keyword",
    "path": "Default",
    "type": "http",
    "http": {
        "blueprint": {
            "url": "https://api.example.com/products/search",
            "method": "GET",
            "headers": {"Accept": "application/json"},
            "timeout": 30,
        },
        "arguments": {
            "query": {
                "type": "string",
                "description": "Search keyword",
                "send_to_model": True,
            }
        },
    },
})

import { Orq } from "@orq-ai/node";

const orq = new Orq({ apiKey: process.env["ORQ_API_KEY"] ?? "" });

const tool = await orq.tools.create({
  key: "search_products",
  displayName: "Search Products",
  description: "Searches the product catalog by keyword",
  path: "Default",
  type: "http",
  http: {
    blueprint: {
      url: "https://api.example.com/products/search",
      method: "GET",
      headers: { Accept: "application/json" },
      timeout: 30,
    },
    arguments: {
      query: {
        type: "string",
        description: "Search keyword",
        sendToModel: true,
      },
    },
  },
});

See the full Create Tool API reference.

Pipe the body via --stdin for tool types other than function; per-field flags currently validate --type against function only.

echo '{
  "key": "search_products",
  "display_name": "Search Products",
  "description": "Searches the product catalog by keyword",
  "path": "Default",
  "type": "http",
  "http": {
    "blueprint": {
      "url": "https://api.example.com/products/search",
      "method": "GET",
      "headers": { "Accept": "application/json" },
      "arguments": {
        "query": {
          "type": "string",
          "description": "Search keyword",
          "send_to_model": true
        }
      }
    }
  }
}' | orq tools create --stdin

See install and setup to get started with the CLI. Run orq tools create --help for the full flag reference.

MCP Tool

AI Studio
API & SDK
CLI

Connect to a Model Context Protocol server. Orq.ai discovers available tools automatically. Provide an optional Bearer token for private servers.

Add a new Tool to a Project

Use the button to add a new Entity to a Project.

Enter Tool Details

Enter the main details of the tool:

Key, used by models to reference the tool
Name, used in the studio to find the tool
Description, used to describe the tool
Make the Description as precise as possible, it is used notably by Agents when looking up relevant tools for their tasks.
MCP Server URL, a valid MCP server endpoint
Header, key-value pairs sent with every request to the MCP server. Use {{variable}} syntax for sensitive values such as API keys.

Create Mcp Tool Pn — Configure all fields

MCP Provider templatesUse the MCP Provider dropdown to select from a curated list of pre-configured providers. Selecting a provider pre-fills Key, Name, and Headers with the correct values for that provider, including any required authentication headers using {{variable}} placeholders.When template variables are detected, a prompt appears below the form asking for temporary values. These values are used only to connect to the MCP server and discover its available tools. They are not stored after the connection.

View all supported providers

Provider	Server URL
Aiera	`https://mcp-pub.aiera.com/`
Airtable	`https://mcp.airtable.com/mcp`
Airwallex Developer	`https://mcp-demo.airwallex.com/developer`
Amplitude	`https://mcp.amplitude.com/mcp`
Apollo.io	`https://mcp.apollo.io/mcp`
Asana	`https://mcp.asana.com/v2/mcp`
Atlassian Rovo	`https://mcp.atlassian.com/v1/mcp`
Attio	`https://mcp.attio.com/mcp`
Aura	`https://mcp.auraintelligence.com/mcp`
AWS Marketplace	`https://marketplace-mcp.us-east-1.api.aws/mcp`
Base44	`https://app.base44.com/mcp`
Bigdata.com	`https://mcp.bigdata.com/`
BioRender	`https://mcp.services.biorender.com/mcp`
Bitly	`https://api-ssl.bitly.com/v4/mcp`
Box	`https://mcp.box.com`
Brex	`https://api.brex.com/mcp`
Calendly	`https://mcp.calendly.com`
Campfire	`https://api.meetcampfire.com/mcp`
Candid	`https://mcp.candid.org/mcp`
Canva	`https://mcp.canva.com/mcp`
CB Insights	`https://mcp.cbinsights.com`
CData Connect AI	`https://mcp.cloud.cdata.com/mcp`
Chronograph	`https://ai.chronograph.pe/mcp`
Circleback	`https://app.circleback.ai/api/mcp`
Clarify	`https://api.clarify.ai/mcp`
Clay	`https://api.clay.com/v3/mcp`
ClickUp	`https://mcp.clickup.com/mcp`
Close	`https://mcp.close.com/mcp`
Cloudflare Developer Platform	`https://bindings.mcp.cloudflare.com/mcp`
Cloudinary	`https://asset-management.mcp.cloudinary.com/sse`
Common Room	`https://mcp.commonroom.io/mcp`
Consensus	`https://mcp.consensus.app/mcp`
Context7	`https://mcp.context7.com/mcp`
Coupler.io	`https://mcp.coupler.io/mcp/`
Craft	`https://mcp.craft.do/my/mcp`
Crossbeam	`https://mcp.crossbeam.com`
Daloopa	`https://mcp.daloopa.com/server/mcp`
Day AI	`https://day.ai/api/mcp`
DevRev	`https://api.devrev.ai/mcp/v1`
DocuSeal	`https://docuseal.com/mcp`
Docusign	`https://mcp.docusign.com/mcp`
Egnyte	`https://mcp-server.egnyte.com/mcp`
Enterpret Wisdom	`https://wisdom-api.enterpret.com/server/mcp`
Exa	`https://mcp.exa.ai/mcp`
FactSet	`https://mcp.factset.com/content/v1`
Fellow.ai	`https://fellow.app/mcp`
Fever Event Discovery	`https://data-search.apigw.feverup.com/mcp`
Figma	`https://mcp.figma.com/mcp`
Fireflies	`https://api.fireflies.ai/mcp`
Fiscal.ai	`https://api.fiscal.ai/mcp/sse`
G2	`https://mcp.g2.com/mcp`
Gainsight (Staircase AI)	`https://mcp.staircase.ai/mcp`
Gamma	`https://mcp.gamma.app/mcp`
GitHub	`https://api.githubcopilot.com/mcp/`
Google Cloud BigQuery	`https://bigquery.googleapis.com/mcp`
Google Compute Engine	`https://compute.googleapis.com/mcp`
Granola	`https://mcp.granola.ai/mcp`
Guru	`https://mcp.api.getguru.com/mcp`
Gusto	`https://mcp.api.gusto.com/anthropic`
Harvey	`https://api.harvey.ai/hosted_mcp/mcp`
Honeycomb	`https://mcp.honeycomb.io/mcp`
HubSpot	`https://mcp.hubspot.com/anthropic`
Hugging Face	`https://huggingface.co/mcp`
IFTTT	`https://ifttt.com/mcp`
Indeed	`https://mcp.indeed.com/claude/mcp`
Intercom	`https://mcp.intercom.com/mcp`
Intuit Credit Karma	`https://anthropic.mcp.creditkarma.com/mcp`
Intuit Mailchimp	`https://ai-inc.mailchimp.com/claude/mcp/v2`
Jam	`https://mcp.jam.dev/mcp`
Jentic	`https://api.jentic.com/mcp`
Jotform	`https://mcp.jotform.com/mcp-app`
Klaviyo	`https://mcp.klaviyo.com/mcp`
Krisp	`https://mcp.krisp.ai/mcp`
LegalZoom	`https://www.legalzoom.com/mcp/claude/v1`
Lilt	`https://mcp.lilt.com/mcp`
Linear	`https://mcp.linear.app/mcp`
Local Falcon	`https://mcp.localfalcon.com`
Lorikeet	`https://api.lorikeetcx.ai/v1/mcp`
LSEG	`https://api.analytics.lseg.com/lfa/mcp`
Lucid	`https://mcp.lucid.app/mcp`
Lumin	`https://mcp.luminpdf.com/mcp`
LunarCrush	`https://lunarcrush.ai/mcp`
Magic Patterns	`https://mcp.magicpatterns.com/mcp`
MailerLite	`https://mcp.mailerlite.com/mcp`
Make	`https://mcp.make.com`
Medidata	`https://mcp.imedidata.com/mcp`
Melon	`https://mcp.melon.com/mcp/`
Mem	`https://mcp.mem.ai/mcp`
Mercury	`https://mcp.mercury.com/mcp`
Metaview	`https://mcp.metaview.ai/mcp`
Miro	`https://mcp.miro.com/`
Mixpanel	`https://mcp.mixpanel.com/mcp`
monday.com	`https://mcp.monday.com/mcp`
Moody’s	`https://api.moodys.com/genai-ready-data/m1/mcp`
Morningstar	`https://mcp.morningstar.com/mcp`
MotherDuck	`https://api.motherduck.com/mcp`
MSCI	`https://mcp.msci.com/mcp/v1.0/mcp`
MT Newswires	`https://vast-mcp.blueskyapi.com/mcp`
Netlify	`https://netlify-mcp.netlify.app/mcp`
Notion	`https://mcp.notion.com/mcp`
Omni Analytics	`https://callbacks.omniapp.co/callback/mcp`
Orq.ai	`https://my.orq.ai/v2/mcp`
Outreach	`https://api.outreach.io/mcp/`
Owkin	`https://mcp.k.owkin.com/mcp`
PagerDuty	`https://mcp.pagerduty.com/mcp`
PayPal	`https://mcp.paypal.com/mcp`
PitchBook Premium	`https://premium.mcp.pitchbook.com/mcp`
Plaid Developer Tools	`https://api.dashboard.plaid.com/mcp/sse`
PlanetScale	`https://mcp.pscale.dev/mcp/planetscale`
PostHog	`https://mcp.posthog.com/mcp`
Postman	`https://mcp.postman.com/minimal`
Process Street	`https://mcp.process.st`
Pylon	`https://mcp.usepylon.com/`
Quartr	`https://mcp.quartr.com/mcp`
Ramp	`https://ramp-mcp-remote.ramp.com/mcp`
Razorpay	`https://mcp.razorpay.com/mcp`
S&P Global	`https://kfinance.kensho.com/integrations/mcp`
Sanity	`https://mcp.sanity.io`
Scholar Gateway	`https://connector.scholargateway.ai/mcp`
Sentry	`https://mcp.sentry.dev/mcp`
SignNow	`https://mcp-server.signnow.com/mcp`
Similarweb	`https://mcp.similarweb.com`
Slack	`https://mcp.slack.com/mcp`
Square	`https://mcp.squareup.com/sse`
Stripe	`https://mcp.stripe.com`
Stytch	`https://mcp.stytch.dev/mcp`
Supabase	`https://mcp.supabase.com/mcp`
Supermetrics	`https://mcp.supermetrics.com/mcp`
Synapse.org	`https://mcp.synapse.org/mcp`
Tango	`https://govcon.dev/mcp`
Tavily	`https://mcp.tavily.com/mcp`
Ticket Tailor	`https://mcp.tickettailor.ai/mcp`
Udemy Business	`https://api.udemy.com/mcp`
Vercel	`https://mcp.vercel.com/`
Webflow	`https://mcp.webflow.com/mcp`
Windsor.ai	`https://mcp.windsor.ai`
Wix	`https://mcp.wix.com/mcp`
Yardi Virtuoso	`https://mcp.virtuoso.ai/mcp`
Zapier	`https://mcp.zapier.com/api/v1/connect`
Zocks	`https://mcp.zocks.io/v1/mcp`
ZoomInfo	`https://mcp.zoominfo.com/mcp`

View your MCP configuration

MCP Tools are automatically configured, you can then visualize all the capabilities and actions dynamically fetched from the MCP Server. Use the button to remove a tool from the list.Use the Refresh button to fetch a new configuration.

An MCP Tool connects to an external Model Context Protocol server. Orq.ai fetches the available capabilities from the server automatically. The server URL must be reachable at creation time.For private MCP servers, use the headers field to pass authentication tokens. Header values are stored securely when encrypted is set to true.

Field	Required	Description
`key`	Yes	Unique identifier (alphanumeric, hyphens, underscores)
`path`	Yes	Project path, e.g. `"Default"`
`type`	Yes	Must be `"mcp"`
`description`	Yes	Used by agents to decide when and how to call the tool
`display_name`	No	Human-readable name shown in the Studio
`mcp.server_url`	Yes	HTTPS endpoint of the MCP server
`mcp.connection_type`	No	`"http"` (default) or `"sse"`
`mcp.headers`	No	HTTP headers sent with every request. Mark sensitive values with `"encrypted": true`

curl -X POST https://my.orq.ai/v2/tools \
  -H "Authorization: Bearer $ORQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "key": "orq_docs_mcp",
    "display_name": "Orq Docs MCP",
    "description": "Search Orq.ai documentation and get integration guidance",
    "path": "Default",
    "type": "mcp",
    "mcp": {
      "server_url": "https://docs.orq.ai/mcp",
      "connection_type": "http",
      "headers": {
        "Authorization": { "value": "Bearer $MY_TOKEN", "encrypted": true }
      }
    }
  }'

from orq_ai_sdk import Orq
import os

orq = Orq(api_key=os.environ["ORQ_API_KEY"])

tool = orq.tools.create(request={
    "key": "orq_docs_mcp",
    "display_name": "Orq Docs MCP",
    "description": "Search Orq.ai documentation and get integration guidance",
    "path": "Default",
    "type": "mcp",
    "mcp": {
        "server_url": "https://docs.orq.ai/mcp",
        "connection_type": "http",
        "headers": {"Authorization": {"value": "Bearer $MY_TOKEN", "encrypted": True}},
    },
})

import { Orq } from "@orq-ai/node";

const orq = new Orq({ apiKey: process.env["ORQ_API_KEY"] ?? "" });

const tool = await orq.tools.create({
  key: "orq_docs_mcp",
  displayName: "Orq Docs MCP",
  description: "Search Orq.ai documentation and get integration guidance",
  path: "Default",
  type: "mcp",
  mcp: {
    serverUrl: "https://docs.orq.ai/mcp",
    connectionType: "http",
    headers: { Authorization: { value: "Bearer $MY_TOKEN", encrypted: true } },
  },
});

See the full Create Tool API reference.

Pipe the body via --stdin for tool types other than function; per-field flags currently validate --type against function only.

echo '{
  "key": "orq_docs_mcp",
  "display_name": "Orq Docs MCP",
  "description": "Search Orq.ai documentation and get integration guidance",
  "path": "Default",
  "type": "mcp",
  "mcp": {
    "server_url": "https://docs.orq.ai/mcp",
    "connection_type": "http",
    "headers": {
      "Authorization": { "value": "Bearer $MY_TOKEN", "encrypted": true }
    }
  }
}' | orq tools create --stdin

See install and setup to get started with the CLI. Run orq tools create --help for the full flag reference.

Python Tool

Python code is limited to 1 MB (1,048,576 bytes) per tool: roughly 1 million characters, or about 20,000 lines of typical Python. Larger code returns a Code exceeds maximum size error and does not run.

AI Studio
API & SDK
CLI

Run arbitrary Python code at runtime. Access parameters via params and store the result in result.

Add a new Tool to a Project

Use the button to add a new Entity to a Project.

Enter Tool Details

Enter the main details of the tool:

Key, used by models to reference the tool
Name, used in the studio to find the tool
Description, used to describe the tool
Make the Description as precise as possible, it is used notably by Agents when looking up relevant tools for their tasks.

Create Python Tool — Configure all fields

Configure your Python Tool

Freely define the code to be ran during Tool execution.You can define the JSON Schema for the parameters to be sent into the tool. Here, see the name field defined and then further fetched using params.get('name').Ensure your return value is stored within the result field.

Python Tool Config — Configure your Python Tool

Publish your Tool

Once your tool is configured, click Publish to save a new version. Each published version is immutable and tracked in the version history.

A Python Tool runs Python code at runtime. Define the logic directly in the code field and declare expected parameters using a JSON Schema.

Field	Required	Description
`key`	Yes	Unique identifier (alphanumeric, hyphens, underscores)
`path`	Yes	Project path, e.g. `"Default"`
`type`	Yes	Must be `"code"`
`description`	Yes	Used by agents to decide when and how to call the tool
`display_name`	No	Human-readable name shown in the Studio
`code_tool.language`	Yes	Must be `"python"`
`code_tool.code`	Yes	Python code to execute. Access parameters via `params`, store the result in `result`
`code_tool.parameters`	Yes	JSON Schema object describing the expected input parameters

curl -X POST https://my.orq.ai/v2/tools \
  -H "Authorization: Bearer $ORQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "key": "calculate_discount",
    "display_name": "Calculate Discount",
    "description": "Calculates the discounted price given a price and a discount percentage",
    "path": "Default",
    "type": "code",
    "code_tool": {
      "language": "python",
      "code": "price = float(params.get(\"price\", 0))\ndiscount = float(params.get(\"discount\", 0))\nresult = price * (1 - discount / 100)",
      "parameters": {
        "type": "object",
        "properties": {
          "price": { "type": "number", "description": "Original price" },
          "discount": { "type": "number", "description": "Discount percentage (0-100)" }
        },
        "required": ["price", "discount"]
      }
    }
  }'

from orq_ai_sdk import Orq
import os

orq = Orq(api_key=os.environ["ORQ_API_KEY"])

tool = orq.tools.create(request={
    "key": "calculate_discount",
    "display_name": "Calculate Discount",
    "description": "Calculates the discounted price given a price and a discount percentage",
    "path": "Default",
    "type": "code",
    "code_tool": {
        "language": "python",
        "code": (
            'price = float(params.get("price", 0))\n'
            'discount = float(params.get("discount", 0))\n'
            "result = price * (1 - discount / 100)"
        ),
        "parameters": {
            "type": "object",
            "properties": {
                "price": {"type": "number", "description": "Original price"},
                "discount": {"type": "number", "description": "Discount percentage (0-100)"},
            },
            "required": ["price", "discount"],
        },
    },
})

import { Orq } from "@orq-ai/node";

const orq = new Orq({ apiKey: process.env["ORQ_API_KEY"] ?? "" });

const tool = await orq.tools.create({
  key: "calculate_discount",
  displayName: "Calculate Discount",
  description: "Calculates the discounted price given a price and a discount percentage",
  path: "Default",
  type: "code",
  codeTool: {
    language: "python",
    code: [
      'price = float(params.get("price", 0))',
      'discount = float(params.get("discount", 0))',
      "result = price * (1 - discount / 100)",
    ].join("\n"),
    parameters: {
      type: "object",
      properties: {
        price: { type: "number", description: "Original price" },
        discount: { type: "number", description: "Discount percentage (0-100)" },
      },
      required: ["price", "discount"],
    },
  },
});

See the full Create Tool API reference.

Pipe the body via --stdin for tool types other than function; per-field flags currently validate --type against function only.

echo '{
  "key": "calculate_discount",
  "display_name": "Calculate Discount",
  "description": "Calculates the discounted price given a price and a discount percentage",
  "path": "Default",
  "type": "code",
  "code_tool": {
    "language": "python",
    "code": "price = float(params.get(\"price\", 0))\ndiscount = float(params.get(\"discount\", 0))\nresult = price * (1 - discount / 100)",
    "parameters": {
      "type": "object",
      "properties": {
        "price": { "type": "number", "description": "Original price" },
        "discount": { "type": "number", "description": "Discount percentage (0-100)" }
      },
      "required": ["price", "discount"]
    }
  }
}' | orq tools create --stdin

See install and setup to get started with the CLI. Run orq tools create --help for the full flag reference.

Versions

When you are done editing, click Publish to save your changes. You will be prompted to write a commit message and choose a version bump: major, minor, or patch.

Tool version publish — Publish a new version of your Tool

Patch (e.g. v1.0.0 to v1.0.1): small fixes, no behavior change
Minor (e.g. v1.0.0 to v1.1.0): new functionality, backwards compatible
Major (e.g. v1.0.0 to v2.0.0): breaking change or significant rework

Every time you publish, a new version of the tool is created. The Versions tab shows the full history. Versions are numbered (e.g. v1.0.0, v1.1.0) and each entry shows the author and publish timestamp.

Tool versions — Version history in the Versions tab

Use the Compare button to open a diff view to see what changed between versions.

Using Tools

Agents

All tool types are supported. Reference a tool by key in the settings.tools array. Your agent’s instructions must explicitly describe each tool and when to use it.

Learn more about using tools in Agents.

Deployments

Only Function Tools are supported. Import a previously created tool from the Tools tab in the deployment configuration.

Learn more about using tools in Deployments.

Overview

Managed Agents

Context Management

Test & Evaluate

Playground

Function Tool

JSON Schema Tool

HTTP Tool

MCP Tool

Python Tool

Choosing a tool type

Function Tool

Worked example: an Agent that checks stock

JSON Schema Tool

HTTP Tool

MCP Tool

Python Tool

Versions

Using Tools

Function Tool

JSON Schema Tool

HTTP Tool

MCP Tool

Python Tool

​Choosing a tool type

​ Function Tool

​Worked example: an Agent that checks stock

​ JSON Schema Tool

​ HTTP Tool

​ MCP Tool

​ Python Tool

​Versions

​Using Tools

Choosing a tool type

Function Tool

Worked example: an Agent that checks stock

JSON Schema Tool

HTTP Tool

MCP Tool

Python Tool

Versions

Using Tools