SIGN UPLOG IN
X (Twitter)LinkedInGitHubDiscordYouTube

How to integrate Close MCP with Claude Agent SDK

Connect Claude Agent SDK to Close MCP. Create a new sales lead for acme corp, log an outbound call with follow-up notes, and more using natural language, with authentication handled for you.

Get started for freeGet a demo
Close logoClose
Api Key

Close is a CRM platform built for sales teams, combining calling, email automation, and predictive dialers. It streamlines sales workflows and boosts productivity with all-in-one communication tools.

70 Tools45 Triggers

Introduction

This guide walks you through connecting Close to the Claude Agent SDK using the Composio tool router. By the end, you'll have a working Close agent that can create leads and tasks, log calls and emails, send SMS messages, track opportunities, and review activities through natural language commands.

This guide will help you understand how to give your Claude Agent SDK agent real control over a Close account through Composio's Close MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

Also integrate Close with

Claude CodeChatGPTClaude CoworkAntigravityOpenAI Agents SDKCodexOpenClawHermesAtomic AgentGoogle ADKLangChainVercel AI SDKMastra AILlamaIndexCrewAIPydantic AIAutoGen

TL;DR

Here's what you'll learn:
  • Get and set up your Claude/Anthropic and Composio API keys
  • Install the necessary dependencies
  • Initialize Composio and create a Tool Router session for Close
  • Configure an AI agent that can use Close as a tool
  • Run a live chat session where you can ask the agent to perform Close operations

What is Claude Agent SDK?

The Claude Agent SDK is Anthropic's official framework for building AI agents powered by Claude. It provides a streamlined interface for creating agents with MCP tool support and conversation management.

Key features include:

  • Native MCP Support: Built-in support for Model Context Protocol servers
  • Permission Modes: Control tool execution permissions
  • Streaming Responses: Real-time response streaming for interactive applications
  • Context Manager: Clean async context management for sessions

What is the Close MCP server, and what's possible with it?

The Close MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Close account. It provides structured and secure access to your sales pipeline, so your agent can perform actions like creating leads, logging calls, sending SMS, managing tasks, and retrieving notes on your behalf.

  • Lead creation and management: Instantly create new leads with company details and contact information, keeping your CRM fresh and organized without manual entry.
  • Automated call logging: Have your agent log both inbound and outbound calls to specific leads, capturing call notes, durations, and recordings for seamless tracking.
  • SMS communication: Direct your agent to send or log SMS messages with leads, enabling timely follow-ups and improved client engagement.
  • Task management: Let your agent create tasks, set due dates, and track completion, making sure nothing slips through the cracks in your sales workflow.
  • Note retrieval and analysis: Fetch notes by lead or date, so your agent can summarize past interactions, surface important insights, or prepare for upcoming calls.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step09 STEPS
1

Prerequisites

Before starting, make sure you have:
  • Composio API Key and Claude/Anthropic API Key
  • Primary know-how of Claude Agents SDK
  • A Close account
  • Some knowledge of Python
2

Getting API Keys for Claude/Anthropic and Composio

Claude/Anthropic API Key
  • Go to the Anthropic Console and create an API key. You'll need credits to use the models.
  • Keep the API key safe.
Composio API Key
  • Log in to the Composio dashboard.
  • Navigate to your API settings and generate a new API key.
  • Store this key securely as you'll need it for authentication.
3

Install dependencies

npm install @anthropic-ai/claude-agent-sdk @composio/core dotenv

Install the Composio SDK and the Claude Agents SDK.

What's happening:

  • @composio/core provides Composio integration for Anthropic
  • @anthropic-ai/claude-agent-sdk is the core agent framework
  • dotenv/config loads environment variables
4

Set up environment variables

bash
COMPOSIO_API_KEY=your_composio_api_key_here
USER_ID=your_user_id_here
ANTHROPIC_API_KEY=your_anthropic_api_key_here

Create a .env file in your project root.

What's happening:

  • COMPOSIO_API_KEY authenticates with Composio
  • USER_ID identifies the user for session management
  • ANTHROPIC_API_KEY authenticates with Anthropic/Claude
5

Import dependencies

import 'dotenv/config';
import readline from 'node:readline';
import { Composio } from '@composio/core';
import { query, type Options } from "@anthropic-ai/claude-agent-sdk";

dotenv.config();
What's happening:
  • We're importing all necessary libraries including the Claude Agent SDK and Composio
  • The dotenv.config() function loads environment variables from your .env file
  • This setup prepares the foundation for connecting Claude with Close functionality
6

Create a Composio instance and Tool Router session

async function chat() {
  const { COMPOSIO_API_KEY, USER_ID } = process.env;
  if (!COMPOSIO_API_KEY || !USER_ID) {
    throw new Error('COMPOSIO_API_KEY and USER_ID required in .env');
  }

  const composio = new Composio({ apiKey: COMPOSIO_API_KEY });

  // Create Tool Router session for Close
  const session = await composio.create(USER_ID, {
    toolkits: ['close'],
  });
  const mcpUrl = session?.mcp.url;
What's happening:
  • The function checks for the required COMPOSIO_API_KEY environment variable
  • We're creating a Composio instance using our API key
  • The create method creates a Tool Router session for Close
  • The returned url is the MCP server URL that your agent will use
7

Configure Claude Agent with MCP

const options: Options = {
  permissionMode: 'bypassPermissions',
  mcpServers: {
    composio: {
      type: 'http',
      url: mcpUrl,
      headers: { 'x-api-key': COMPOSIO_API_KEY }
    }
  },
  systemPrompt: 'You are a helpful assistant with access to Close tools via Composio.',
  maxTurns: 10,
};
What's happening:
  • We're configuring the Claude Agent options with the MCP server URL
  • permissionMode: 'bypassPermissions' allows the agent to execute operations without asking for permission each time
  • The system prompt instructs the agent that it has access to Close
  • maxTurns: 10 limits the conversation length to prevent excessive API usage
8

Create client and start chat loop

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: 'You: '
  });

  console.log('\nChat started. Type "exit" to quit.\n');

  let isProcessing = false;

  async function ask(prompt: string) {
    isProcessing = true;
    rl.pause();

    process.stdout.write('Claude is thinking...');
    const stream = query({ prompt, options });

    let firstChunk = true;
    for await (const msg of stream) {
      const content = (msg as any).message?.content || (msg as any).content;
      if (Array.isArray(content)) {
        for (const block of content) {
          if (block.type === 'text' && block.text) {
            if (firstChunk) {
              process.stdout.write('\r\x1b[K');
              process.stdout.write('Claude: ');
              firstChunk = false;
            }
            process.stdout.write(block.text);
          }
        }
      }
    }
    process.stdout.write('\n\n');

    isProcessing = false;
    rl.resume();
    rl.prompt();
  }

  rl.on('line', async (line) => {
    if (isProcessing) return;

    const input = line.trim();
    if (input === 'exit') {
      rl.close();
      process.exit(0);
    }
    if (input) await ask(input);
    else rl.prompt();
  });

  await ask('What can you help me with?');
}
What's happening:
  • The readline interface is created to handle user input and output
  • The query function is used to send the user's input to the agent
  • The chat loop continues until the user types 'exit' or 'quit'
9

Run the application

try {
  await chat();
} catch (error) {
  console.error(error);
  process.exit(1);
}
What's happening:
  • The chat function is the entry point for the application
  • The try-catch block is used to handle any errors that occur

Complete Code

Here's the complete code to get you started with Close and Claude Agent SDK:

import 'dotenv/config';
import readline from 'node:readline';
import { Composio } from '@composio/core';
import { query, type Options } from "@anthropic-ai/claude-agent-sdk";

async function chat() {
  const { COMPOSIO_API_KEY, USER_ID } = process.env;
  if (!COMPOSIO_API_KEY || !USER_ID) {
    throw new Error('COMPOSIO_API_KEY and USER_ID required in .env');
  }

  const composio = new Composio({ apiKey: COMPOSIO_API_KEY });
  const session = await composio.create(USER_ID, {
    toolkits: ['close']
  });
  const mcp_url = session?.mcp.url;

  const options: Options = {
    permissionMode: 'bypassPermissions',
    mcpServers: {
      composio: {
        type: 'http',
        url: mcp_url,
        headers: { 'x-api-key': COMPOSIO_API_KEY }
      }
    },
    systemPrompt: 'You are a helpful assistant with access to Close tools via Composio.',
    maxTurns: 10,
  };

  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: 'You: '
  });

  console.log('\nChat started. Type "exit" to quit.\n');

  let isProcessing = false;

  async function ask(prompt: string) {
    isProcessing = true;
    rl.pause();

    process.stdout.write('Claude is thinking...');
    const stream = query({ prompt, options });

    let firstChunk = true;
    for await (const msg of stream) {
      const content = (msg as any).message?.content || (msg as any).content;
      if (Array.isArray(content)) {
        for (const block of content) {
          if (block.type === 'text' && block.text) {
            if (firstChunk) {
              process.stdout.write('\r\x1b[K');
              process.stdout.write('Claude: ');
              firstChunk = false;
            }
            process.stdout.write(block.text);
          }
        }
      }
    }
    process.stdout.write('\n\n');

    isProcessing = false;
    rl.resume();
    rl.prompt();
  }

  rl.on('line', async (line) => {
    if (isProcessing) return;

    const input = line.trim();
    if (input === 'exit') {
      rl.close();
      process.exit(0);
    }
    if (input) await ask(input);
    else rl.prompt();
  });

  await ask('What can you help me with?');
}

try {
  await chat();
} catch (error) {
  console.error(error);
  process.exit(1);
}

Conclusion

You've successfully built a Claude Agent SDK agent that can interact with Close through Composio's Tool Router.

Key features:

  • Native MCP support through Claude's agent framework
  • Streaming responses for real-time interaction
  • Permission bypass for smooth automated workflows
You can extend this by adding more toolkits, implementing custom business logic, or building a web interface around the agent.
TOOLS & TRIGGERS

Supported Tools and Triggers

Every Close action and event your agent gets out of the box.

Create Call

Creates a new call record in Close.

Create Contact

Create a contact on an existing Close lead, or create a new lead named after the contact when lead_id is omitted.

Create Custom Activity

Create a draft or published custom activity instance on a Close lead.

Create Custom Field

Create a custom-field definition for Close leads or opportunities.

Create Email

Create or log a Close email activity.

Create Lead

Creates a new lead in Close CRM.

Create Note

Create a plaintext or rich-text note activity on a Close lead.

Create Opportunity

Create a Close sales opportunity on an existing lead, or create an Untitled lead for it when lead_id is omitted.

Create Sequence

Create a Close sales sequence with ordered call or email steps.

Create SMS Message

Create an SMS activity on a Close lead to log received, sent, or draft messages, or to send or schedule a message.

Create Task

Create a Close task associated with a lead, using task text and an actionable date, with optional completion status and assignment.

Delete Activity Custom Field

Permanently delete one Close activity custom-field definition by ID.

Delete Call

This tool allows you to delete a specific call activity in Close.

Delete Custom Activity

Permanently delete one Close custom activity instance by ID.

Delete Email

This tool allows you to permanently delete a specific email activity in Close.

Delete Lead

Permanently delete one Close lead by ID.

Delete Lead Custom Field

Permanently delete a Close lead custom-field definition and its values.

Delete Note

Permanently delete one Close note activity by ID.

Delete Opportunity

Permanently delete one Close opportunity by ID.

Delete Opportunity Status

Permanently delete an unused Close opportunity status; this cannot be undone.

Delete SMS

Permanently delete one Close SMS activity by ID.

Download File

Download bytes from a provider-issued Close Files API URL.

Get Activity Custom Field

Retrieve one Close activity custom-field definition by ID.

Get Call

Retrieve one Close call activity by ID with optional field projection.

Get Contact

Retrieve one Close contact by ID, optionally limiting returned fields.

Get Created Activity

Retrieve one Close lead-creation activity with optional field projection.

Get Email

Retrieve one Close email activity by ID with optional field projection.

Get Event

Retrieve one Close event-log record by event ID.

Get Lead

Retrieve one Close lead by ID with optional field projection.

Get Lead Custom Field

Retrieve one Close lead custom-field definition by ID.

Get Notes

This tool retrieves a list of note activities from Close.

Get Note by ID

Retrieve one Close note activity by ID with optional field projection.

Get Opportunity

Retrieve one Close opportunity by ID with optional field projection.

Get Sequence

Retrieve one Close sequence by ID with its workflow configuration.

Get Shared Custom Field

Retrieve one Close shared custom-field definition by ID.

Get SMS

Retrieve one Close SMS activity by ID with optional field projection.

Get Task

Retrieve one Close task by ID with optional field projection.

Get User

Retrieve one Close organization user by ID with optional field projection.

List Activities

Lists one page of Close email or call activities using documented filters.

List Contacts

List Close contacts with lead filtering, projection, and offset pagination.

List Custom Activities

List Close custom activity instances with filters and offset pagination.

List Custom Activity Types

This tool lists the custom activity types defined in a Close organization, returning each type's id and name.

List Custom Objects

List custom object instances attached to a Close lead, optionally by type.

List Custom Object Types

This tool lists the custom object types defined in a Close organization, returning each type's id and name.

List Events

List Close change events with filters, projection, and cursor pagination.

List Lead Custom Fields

List Close lead custom-field definitions with projection and pagination.

List Leads

List or text-search Close leads with field projection and offset pagination.

List Lead Statuses

List the configured lead statuses for the connected organization.

List Opportunities

List a page of Close opportunities with offset pagination.

List Opportunity Custom Fields

List Close opportunity custom-field definitions with projection and pagination.

List Opportunity Statuses

List the configured opportunity statuses for the connected organization.

List Outcomes

List Close call and meeting outcomes with projection and offset pagination.

List Pipelines

List pipelines and their ordered opportunity statuses.

List Sequences

List Close sales sequences with offset pagination.

List Sequence Subscriptions

List Close sequence subscriptions.

List Tasks

List Close tasks using task, assignee, lead, date, and pagination filters.

List Unified Activities

List one page of Close activities across all types and matching filters.

List Users

List users in the connected Close organization with offset pagination.

List Webhook Subscriptions

List webhook subscriptions configured for the Close organization.

Search Data

Search Close objects using the structured Advanced Filtering query language.

Update Activity Custom Field

Update mutable settings of one Close activity custom-field definition.

Update Contact

Update standard and custom fields on one existing Close contact.

Update Custom Activity

Update standard and custom fields on one Close custom activity instance.

Update Email

Update an existing Close email activity.

Update Lead Custom Field

Update a Close lead custom-field definition.

Update Note

Update the mutable content and metadata of one Close note activity.

Update Opportunity

Update standard and custom fields on one Close opportunity.

Update Sequence

Update a Close sequence name or replace its entire ordered step list.

Update Task

Update assignment, actionable date, or completion state on a Close task; lead tasks can also update text.

Who Am I

Return the identity (email, name) of the connected Close account.

FRAMEWORKS

How to build Close MCP Agent with another framework

Claude Code logo

Claude Code

Use Close MCP with Claude Code

ChatGPT logo

ChatGPT

Use Close MCP with ChatGPT

Claude Cowork logo

Claude Cowork

Use Close MCP with Claude Cowork

Antigravity logo

Antigravity

Use Close MCP with Antigravity

OpenAI Agents SDK logo

OpenAI Agents SDK

Use Close MCP with OpenAI Agents SDK

Codex logo

Codex

Use Close MCP with Codex

OpenClaw logo

OpenClaw

Use Close MCP with OpenClaw

Hermes logo

Hermes

Use Close MCP with Hermes

Atomic Agent logo

Atomic Agent

Use Close MCP with Atomic Agent

Google ADK logo

Google ADK

Use Close MCP with Google ADK

LangChain logo

LangChain

Use Close MCP with LangChain

Vercel AI SDK logo

Vercel AI SDK

Use Close MCP with Vercel AI SDK

Mastra AI logo

Mastra AI

Use Close MCP with Mastra AI

LlamaIndex logo

LlamaIndex

Use Close MCP with LlamaIndex

CrewAI logo

CrewAI

Use Close MCP with CrewAI

Pydantic AI logo

Pydantic AI

Use Close MCP with Pydantic AI

AutoGen logo

AutoGen

Use Close MCP with AutoGen

FAQ

Frequently asked questions

Start with Close.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Close tool your agent needs.Free to start.

Start building