What is Attio Mcp

attio-mcp is an implementation of the Attio Model Context Protocol (MCP) server designed to facilitate communication between MCP clients and the Attio API, which is an AI-native CRM platform.

Use cases

Use cases for attio-mcp include managing customer data, automating note-taking for companies and individuals, organizing lists for sales leads, and integrating AI capabilities into CRM workflows.

How to use

To use attio-mcp, you need to set up your environment with the ATTIO_API_KEY, which can be obtained from the Attio API Explorer. You can configure the MCP server in your client application (like Claude) using the provided JSON configuration.

Key features

Key features of attio-mcp include: Company API for searching and managing company details and notes, People API for handling person details and notes, and Lists API for managing lists and their entries. Tasks and Records APIs are planned for future implementation.

Where to use

attio-mcp can be used in various fields that require customer relationship management, such as sales, marketing, and customer support, particularly where AI-driven insights and automation are beneficial.

attio-mcp-server

This is an MCP server for Attio, the AI-native CRM. It allows MCP clients (like Claude) to connect to the Attio API.

Current Capabilities

• [x] Company API
  • [x] searching companies
  • [x] reading company details
  • [x] reading company notes
  • [x] creating company notes
• [x] People API
  • [x] searching people
  • [x] reading person details
  • [x] reading person notes
  • [x] creating person notes
• [x] Lists API
  • [x] getting all lists
  • [x] getting list details
  • [x] getting list entries
  • [x] adding records to lists
  • [x] removing records from lists
• [ ] Tasks API
• [ ] Records API

Usage

You will need:

• ATTIO_API_KEY

This is expected to be a bearer token which means you can get one through the API Explorer on the right hand side or configure OAuth and retrieve one throught the Attio API.

Claude Desktop Configuration

{
  "mcpServers": {
    "attio": {
      "command": "npx",
      "args": [
        "attio-mcp-server"
      ],
      "env": {
        "ATTIO_API_KEY": "YOUR_ATTIO_API_KEY"
      }
    }
  }
}

For local development, you can use npm link:

# In the attio-mcp directory
npm run build && npm link

# In your Claude Desktop configuration
# Change the command to use the linked version
{
  "mcpServers": {
    "attio": {
      "command": "node",
      "args": ["PATH_TO_YOUR_REPO/dist/index.js"],
      "env": {
        "ATTIO_API_KEY": "YOUR_ATTIO_API_KEY"
      }
    }
  }
}

Development

Prerequisites

Before you begin, ensure you have the following installed:

• Node.js (recommended v18 or higher)
• npm
• git
• dotenv
• Docker and Docker Compose (optional, for containerized development)

Setting up Development Environment

To set up the development environment, follow these steps:

1. Fork the repository

   • Click the “Fork” button in the top-right corner of this repository
   • This creates your own copy of the repository under your Github account

2. Clone Your Fork:

   git clone https://github.com/YOUR_USERNAME/attio-mcp.git
   cd attio-mcp
   

3. Add Upstream Remote

   git remote add upstream https://github.com/kesslerio/attio-mcp.git
   

4. Copy the dotenv file

   cp .env.template .env
   

5. Install dependencies:

   npm install
   

6. Run watch to keep index.js updated:

   npm run build:watch
   

7. Start the model context protocol development server:

   dotenv npx @modelcontextprotocol/inspector node ./dist/index.js
   

8. If the development server did not load the environment variable correctly, set the ATTIO_API_KEY on the left-hand side of the mcp inspector.

Docker Support

You can also run the Attio MCP Server in a Docker container, which simplifies deployment and ensures consistency across different environments.

Building the Docker Image

# Build using the provided script
./scripts/docker-build.sh

# Or build with custom name and tag
./scripts/docker-build.sh --name my-attio-mcp --tag v1.0.0

Running with Docker Compose

1. Set up your environment variables in a .env file:

   ATTIO_API_KEY=your_api_key_here
   

2. Start the container using Docker Compose:

   docker compose up -d
   

3. Check logs:

   docker compose logs -f
   

4. Stop the container:

   docker compose down
   

Running with Docker Directly

docker run -p 9876:3000 \
  -e ATTIO_API_KEY=your_api_key_here \
  --restart unless-stopped \
  --name attio-mcp-server \
  attio-mcp-server:latest

Docker Configuration for Claude

To use the dockerized Attio MCP Server with Claude:

{
  "mcpServers": {
    "attio": {
      "url": "http://localhost:9876"
    }
  }
}

The server is configured to use port 9876 externally to avoid conflicts with common services. You can change this port in the docker-compose.yml file if needed.

Docker Health Check

The Docker container includes a health check that monitors the server’s status. You can view the health status with:

docker ps -a