Mcp Server For Intercom
Overview
What is MCP Server for Intercom?
The ### MCP Server for Intercom is an innovative solution designed to enhance communication and integration capabilities for businesses using the Intercom platform. This server acts as a bridge, allowing seamless data exchange between various applications and the Intercom system, thereby improving customer engagement and support processes.
Features of MCP Server for Intercom
- Real-time Data Synchronization: Ensures that all customer interactions and data are updated in real-time across platforms.
- Customizable Integrations: Offers flexibility to integrate with various third-party applications, tailored to specific business needs.
- User-friendly Interface: Designed with an intuitive interface that simplifies the management of customer interactions.
- Scalability: Easily scalable to accommodate growing business needs and increasing customer interactions.
- Robust Security: Implements advanced security measures to protect sensitive customer data during transmission.
How to Use MCP Server for Intercom
- Installation: Begin by downloading the MCP Server for Intercom from the official repository. Follow the installation instructions provided in the documentation.
- Configuration: Configure the server settings to connect with your Intercom account and any other applications you wish to integrate.
- Testing: Conduct tests to ensure that data is being synchronized correctly and that all integrations are functioning as expected.
- Deployment: Once testing is complete, deploy the server in your production environment.
- Monitoring and Maintenance: Regularly monitor the server performance and update configurations as necessary to adapt to changing business requirements.
Frequently Asked Questions
What platforms does MCP Server for Intercom support?
MCP Server for Intercom supports various platforms, including CRM systems, e-commerce platforms, and other customer engagement tools.
Is there a cost associated with using MCP Server for Intercom?
The MCP Server for Intercom is open-source and free to use, but additional costs may arise from third-party integrations or hosting services.
How can I contribute to the MCP Server for Intercom project?
Contributions are welcome! You can contribute by reporting issues, suggesting features, or submitting code improvements via the GitHub repository.
What kind of support is available for MCP Server for Intercom?
Support is available through the community forums, GitHub issues page, and documentation. Users can also seek help from other developers who have experience with the server.
Can I customize the MCP Server for Intercom?
Yes, the server is designed to be customizable. You can modify the code to fit your specific business needs and integrate additional functionalities as required.
Details
MCP Server for Intercom
<a href="https://glama.ai/mcp/servers/@raoulbia-ai/mcp-server-for-intercom"> <img width="380" height="200" src="https://glama.ai/mcp/servers/@raoulbia-ai/mcp-server-for-intercom/badge" /> </a>An MCP-compliant server that enables AI assistants to access and analyze customer support data from Intercom.
Features
- Search conversations and tickets with advanced filtering
- Filter by customer, status, date range, and keywords
- Search by email content even when no contact exists
- Efficient server-side filtering via Intercom's search API
- Seamless integration with MCP-compliant AI assistants
Installation
Prerequisites
- Node.js 18.0.0 or higher
- An Intercom account with API access
- Your Intercom API token (available in your Intercom account settings)
Quick Setup
Using NPM
### Install the package globally
npm install -g mcp-server-for-intercom
### Set your Intercom API token
export INTERCOM_ACCESS_TOKEN="your_token_here"
### Run the server
intercom-mcp
Using Docker
The default Docker configuration is optimized for Glama compatibility:
### Start Docker (if not already running)
### On Windows: Start Docker Desktop application
### On Linux: sudo systemctl start docker
### Build the image
docker build -t mcp-intercom .
### Run the container with your API token and port mappings
docker run --rm -it -p 3000:3000 -p 8080:8080 -e INTERCOM_ACCESS_TOKEN="your_token_here" mcp-intercom:latest
Validation Steps:
### Test the server status
curl -v http://localhost:8080/.well-known/glama.json
### Test the MCP endpoint
curl -X POST -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","id":1,"method":"mcp.capabilities"}' http://localhost:3000
Alternative Standard Version
If you prefer a lighter version without Glama-specific dependencies:
### Build the standard image
docker build -t mcp-intercom-standard -f Dockerfile.standard .
### Run the standard container
docker run --rm -it -p 3000:3000 -p 8080:8080 -e INTERCOM_ACCESS_TOKEN="your_token_here" mcp-intercom-standard:latest
The default version includes specific dependencies and configurations required for integration with the Glama platform, while the standard version is more lightweight.
Available MCP Tools
1. list_conversations
Retrieves all conversations within a date range with content filtering.
Parameters:
startDate(DD/MM/YYYY) – Start date (required)endDate(DD/MM/YYYY) – End date (required)keyword(string) – Filter to include conversations with this textexclude(string) – Filter to exclude conversations with this text
Notes:
- Date range must not exceed 7 days
- Uses efficient server-side filtering via Intercom's search API
Example:
{
"startDate": "15/01/2025",
"endDate": "21/01/2025",
"keyword": "billing"
}
2. search_conversations_by_customer
Finds conversations for a specific customer.
Parameters:
customerIdentifier(string) – Customer email or Intercom ID (required)startDate(DD/MM/YYYY) – Optional start dateendDate(DD/MM/YYYY) – Optional end datekeywords(array) – Optional keywords to filter by content
Notes:
- Can find conversations by email content even if no contact exists
- Resolves emails to contact IDs for efficient searching
Example:
{
"customerIdentifier": "customer@example.com",
"startDate": "15/01/2025",
"endDate": "21/01/2025",
"keywords": ["billing", "refund"]
}
3. search_tickets_by_status
Retrieves tickets by their status.
Parameters:
status(string) – "open", "pending", or "resolved" (required)startDate(DD/MM/YYYY) – Optional start dateendDate(DD/MM/YYYY) – Optional end date
Example:
{
"status": "open",
"startDate": "15/01/2025",
"endDate": "21/01/2025"
}
4. search_tickets_by_customer
Finds tickets associated with a specific customer.
Parameters:
customerIdentifier(string) – Customer email or Intercom ID (required)startDate(DD/MM/YYYY) – Optional start dateendDate(DD/MM/YYYY) – Optional end date
Example:
{
"customerIdentifier": "customer@example.com",
"startDate": "15/01/2025",
"endDate": "21/01/2025"
}
Configuration with Claude Desktop
Add to your claude_desktop_config.json:
{
"mcpServers": {
"intercom-mcp": {
"command": "intercom-mcp",
"args": [],
"env": {
"INTERCOM_ACCESS_TOKEN": "your_intercom_api_token"
}
}
}
}
Implementation Notes
For detailed technical information about how this server integrates with Intercom's API, see src/services/INTERCOM_API_NOTES.md. This document explains our parameter mapping, Intercom endpoint usage, and implementation details for developers.
Development
### Clone and install dependencies
git clone https://github.com/raoulbia-ai/mcp-server-for-intercom.git
cd mcp-server-for-intercom
npm install
### Build and run for development
npm run build
npm run dev
### Run tests
npm test
Disclaimer
This project is an independent integration and is not affiliated with, officially connected to, or endorsed by Intercom Inc. "Intercom" is a registered trademark of Intercom Inc.
License
This project is licensed under the Apache License 2.0 - see the LICENSE file for details.
Server Config
{
"mcpServers": {
"mcp-server-for-intercom": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/metorial/mcp-container--raoulbia-ai--mcp-server-for-intercom--mcp-server-for-intercom",
"npm run start"
],
"env": {
"INTERCOM_ACCESS_TOKEN": "intercom-access-token"
}
}
}
}.
Code
```python
import socket
import threading
Server settings
HOST = '127.0.0.1' Localhost
PORT = 12345 Port to listen on
List to keep track of connected clients
clients = []
def handle_client(client_socket, addr):
print(f"Connection from {addr} has been established!")
clients.append(client_socket)
while True:
try:
message = client_socket.recv(1024).decode('utf-8')
if message:
print(f"Received message: {message}")
broadcast(message, client_socket)
else:
break
except:
break
print(f"Connection from {addr} has been closed.")
clients.remove(client_socket)
client_socket.close()
def broadcast(message, client_socket):
for client in clients:
if client != client_socket:
client.send(message.encode('utf-8'))
def start_server():
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((HOST, PORT))
server_socket.listen()
print(f"Server is listening on {HOST}:{PORT}")
while True:
client_socket, addr = server_socket.accept()
thread = threading.Thread(target=handle_client, args=(client_socket, addr))
thread.start()
if __name__ == "__main__":
start_server()
```
How to Run
1. Save the code in a file named `unichat_server.py`.
2. Open a terminal and navigate to the directory where the file is saved.
3. Run the server using the command:
```
python unichat_server.py
```
Connecting Clients
You can create a simple client using the following code:
```python
import socket
HOST = '127.0.0.1' Server address
PORT = 12345 Server port
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((HOST, PORT))
while True:
message = input("Enter message: ")
client_socket.send(message.encode('utf-8'))
```
Conclusion
This is a basic implementation of a chat server in Python. You can enhance it by adding features like user authentication, message history, or a graphical user interface.](https://avatars.githubusercontent.com/u/1759588?v=4 "Unichat MCP Server in Python
Overview
Unichat is a simple chat server that allows multiple clients to connect and communicate with each other. This implementation is done using Python's socket programming.
Requirements
- Python 3.x
- Basic knowledge of socket programming
Installation
Make sure you have Python installed on your machine. You can download it from [python.org](https://www.python.org/downloads/).
Code
```python
import socket
import threading
Server settings
HOST = '127.0.0.1' Localhost
PORT = 12345 Port to listen on
List to keep track of connected clients
clients = []
def handle_client(client_socket, addr):
print(f\"Connection from {addr} has been established!\")
clients.append(client_socket)
while True:
try:
message = client_socket.recv(1024).decode('utf-8')
if message:
print(f\"Received message: {message}\")
broadcast(message, client_socket)
else:
break
except:
break
print(f\"Connection from {addr} has been closed.\")
clients.remove(client_socket)
client_socket.close()
def broadcast(message, client_socket):
for client in clients:
if client != client_socket:
client.send(message.encode('utf-8'))
def start_server():
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((HOST, PORT))
server_socket.listen()
print(f\"Server is listening on {HOST}:{PORT}\")
while True:
client_socket, addr = server_socket.accept()
thread = threading.Thread(target=handle_client, args=(client_socket, addr))
thread.start()
if __name__ == \"__main__\":
start_server()
```
How to Run
1. Save the code in a file named `unichat_server.py`.
2. Open a terminal and navigate to the directory where the file is saved.
3. Run the server using the command:
```
python unichat_server.py
```
Connecting Clients
You can create a simple client using the following code:
```python
import socket
HOST = '127.0.0.1' Server address
PORT = 12345 Server port
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((HOST, PORT))
while True:
message = input(\"Enter message: \")
client_socket.send(message.encode('utf-8'))
```
Conclusion
This is a basic implementation of a chat server in Python. You can enhance it by adding features like user authentication, message history, or a graphical user interface."){kind=small}
