Skip to main content
Glama

retell_create_phone_call

Initiate outbound AI phone calls using registered numbers and configured agents for automated voice interactions.

Instructions

Create a new outbound phone call using Retell AI. Initiates a call from a registered phone number to a target number using a configured AI agent.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
from_numberYesThe caller's phone number in E.164 format (e.g., +14157774444). Must be a number registered with Retell.
to_numberYesThe recipient's phone number in E.164 format (e.g., +12137774445)
override_agent_idNoOptional: Specific agent ID to use for this call instead of the number's default agent
metadataNoOptional: Custom metadata to attach to the call for tracking purposes
retell_llm_dynamic_variablesNoOptional: Dynamic variables to pass to the LLM for personalized responses

Implementation Reference

  • The execution handler for the retell_create_phone_call tool. It calls the retellRequest helper to POST the input arguments to the Retell API endpoint /v2/create-phone-call.
    case "retell_create_phone_call":
      return retellRequest("/v2/create-phone-call", "POST", args);
  • Input schema defining the parameters for creating a phone call: required from_number and to_number, optional override_agent_id, metadata, and retell_llm_dynamic_variables.
    inputSchema: {
      type: "object",
      properties: {
        from_number: {
          type: "string",
          description: "The caller's phone number in E.164 format (e.g., +14157774444). Must be a number registered with Retell."
        },
        to_number: {
          type: "string",
          description: "The recipient's phone number in E.164 format (e.g., +12137774445)"
        },
        override_agent_id: {
          type: "string",
          description: "Optional: Specific agent ID to use for this call instead of the number's default agent"
        },
        metadata: {
          type: "object",
          description: "Optional: Custom metadata to attach to the call for tracking purposes"
        },
        retell_llm_dynamic_variables: {
          type: "object",
          description: "Optional: Dynamic variables to pass to the LLM for personalized responses"
        }
      },
      required: ["from_number", "to_number"]
  • src/index.ts:62-91 (registration)
    Registration of the retell_create_phone_call tool in the tools array used by the MCP server's listTools handler.
    {
      name: "retell_create_phone_call",
      description: "Create a new outbound phone call using Retell AI. Initiates a call from a registered phone number to a target number using a configured AI agent.",
      inputSchema: {
        type: "object",
        properties: {
          from_number: {
            type: "string",
            description: "The caller's phone number in E.164 format (e.g., +14157774444). Must be a number registered with Retell."
          },
          to_number: {
            type: "string",
            description: "The recipient's phone number in E.164 format (e.g., +12137774445)"
          },
          override_agent_id: {
            type: "string",
            description: "Optional: Specific agent ID to use for this call instead of the number's default agent"
          },
          metadata: {
            type: "object",
            description: "Optional: Custom metadata to attach to the call for tracking purposes"
          },
          retell_llm_dynamic_variables: {
            type: "object",
            description: "Optional: Dynamic variables to pass to the LLM for personalized responses"
          }
        },
        required: ["from_number", "to_number"]
      }
    },
  • Helper function retellRequest that performs authenticated HTTP requests to the Retell API, used by the tool handler.
    async function retellRequest(
      endpoint: string,
      method: string = "GET",
      body?: Record<string, unknown>
    ): Promise<unknown> {
      const apiKey = getApiKey();
    
      const headers: Record<string, string> = {
        "Authorization": `Bearer ${apiKey}`,
        "Content-Type": "application/json",
      };
    
      const options: RequestInit = {
        method,
        headers,
      };
    
      if (body && method !== "GET") {
        options.body = JSON.stringify(body);
      }
    
      const response = await fetch(`${RETELL_API_BASE}${endpoint}`, options);
    
      if (!response.ok) {
        const errorText = await response.text();
        throw new Error(`Retell API error (${response.status}): ${errorText}`);
      }
    
      // Handle 204 No Content
      if (response.status === 204) {
        return { success: true };
      }
    
      return response.json();
    }
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden but lacks critical behavioral details. It states the tool 'creates' and 'initiates' a call, implying a write/mutation operation, but doesn't disclose authentication requirements, rate limits, cost implications, error conditions, or what happens after initiation (e.g., call status tracking). For a tool that likely involves external communication and billing, this is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is perfectly concise with two sentences that are front-loaded and zero waste. The first sentence states the core purpose, and the second elaborates on the mechanism. Every word earns its place without redundancy or fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (outbound phone calls with AI agents) and lack of annotations and output schema, the description is minimally adequate but incomplete. It covers the 'what' and basic 'how' but misses critical behavioral context like permissions, side effects, and response format. For a mutation tool with no structured safety hints, more disclosure would be beneficial.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, providing detailed parameter documentation including formats (E.164), optionality, and purposes. The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline of 3 where the schema does the heavy lifting. However, it doesn't compensate with any extra context about parameter interactions or constraints.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Create a new outbound phone call'), identifies the resource ('using Retell AI'), and distinguishes it from siblings by specifying it's for phone calls rather than chats, web calls, or batch calls. It explicitly mentions 'initiates a call from a registered phone number to a target number using a configured AI agent,' which provides complete operational context.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage context by mentioning 'registered phone number' and 'configured AI agent,' suggesting prerequisites, but doesn't explicitly state when to use this tool versus alternatives like retell_create_batch_call or retell_create_web_call. No explicit exclusions or comparative guidance is provided, leaving the agent to infer based on the 'phone call' specificity.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/itsanamune/retellsimp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server