← All Telegram MCP connectors

Cursor, Zed & Windsurf

Cursor Telegram MCP — Telegram in Cursor, Zed & Windsurf

Register Entergram as an MCP server in Cursor, Zed or Windsurf and reach your real Telegram account from your editor — check the messages you missed and the clients waiting on you without breaking flow.

MCP server URL https://mcp.entergram.com/mcp

Cursor, Zed and Windsurf all load MCP servers from an mcp.json file. Add Entergram's URL and your editor's AI can reach your real personal Telegram account between tasks — OAuth-scoped, with no bot account and no API keys in your repo.

Paste-ready configuration

mcp.json (Cursor / Zed / Windsurf)
{
  "mcpServers": {
    "entergram": {
      "url": "https://mcp.entergram.com/mcp"
    }
  }
}

Ask your editor about your Telegram

With your personal account connected, your IDE’s AI can check Telegram without you switching apps. Try:

  • “Who reported this stack trace, and what exactly did they say?”
  • “Has anyone else complained about the same timeout?”
  • “Open a ticket for this bug and link the chat it came from.”
  • “Message the reporter that the fix is merged and shipping today.”
  • “Show me every chat mentioning the endpoint I just changed.”
  • “Leave a note on that thread so support knows the status.”

Connect your editor in 3 steps

Works with Cursor, Zed and Windsurf.

  1. 01

    Copy your MCP URL in Entergram

    From Entergram, open Settings → Workspace → Connectors → MCP and copy the endpoint. It lands in a JSON config file rather than a settings dialog, so keep it on the clipboard.

  2. 02

    Add the server to mcp.json

    In your editor’s MCP settings (mcp.json), register the Entergram MCP URL: https://mcp.entergram.com/mcp.

  3. 03

    Authorize and use

    Reload the MCP server in your editor, complete the browser sign-in, and approve access. The tools register against the workspace you have open.

Three editors, three config files

Cursor — ~/.cursor/mcp.json

Cursor loads servers from ~/.cursor/mcp.json for every project you open, or from .cursor/mcp.json committed inside a repo when you only want the server available to that codebase. The menu route is Cursor Settings → MCP & Integrations → New MCP server, which writes the same file for you. A project-level entry asks for trust the first time the agent reaches for it, so a teammate who pulls the repo still makes a deliberate choice.

{
  "mcpServers": {
    "entergram": {
      "url": "https://mcp.entergram.com/mcp"
    }
  }
}

Zed — ~/.config/zed/settings.json

Zed keeps MCP servers under a context_servers block in its main settings file rather than an mcpServers block, and that one word breaks most first attempts: paste the Cursor snippet verbatim and nothing loads, with no error to explain why. The Agent Panel's settings screen has an Add Custom Server button that writes the correct shape if you would rather not hand-edit JSON.

{
  "context_servers": {
    "entergram": {
      "source": "custom",
      "url": "https://mcp.entergram.com/mcp"
    }
  }
}

Windsurf — ~/.codeium/windsurf/mcp_config.json

Windsurf reads a dedicated file under ~/.codeium rather than the editor settings you might expect, and Cascade rescans it on demand: after saving, open the MCP panel in Cascade and hit refresh, or the tools stay invisible until the next restart. The JSON shape itself matches Cursor's, so the entry is portable between the two.

{
  "mcpServers": {
    "entergram": {
      "url": "https://mcp.entergram.com/mcp"
    }
  }
}

From stack trace to the person who sent it

Your editor already holds the code. What it has never held is the other half of a bug — who hit it, how many of them there are, and what support already promised them. Each question below resolves into a short chain of named tool calls that scroll past in the agent pane while you keep reading the file.

You ask

“Someone sent us a TypeError from the billing page. Find the message and tell me who reported it.”

Tools called

entergram_list_messagesentergram_get_contactentergram_list_chat_tickets

You get

The agent scans recent history for the error text, resolves the sender into a contact record, and checks whether that conversation already produced a ticket. You get the reporter's name, their exact wording, and a yes-or-no on whether support logged it — before you have opened a single file in the repo.

You ask

“Is this worth fixing today? Count how many people have reported the same thing.”

Tools called

entergram_list_workspace_chatsentergram_list_messagesentergram_get_chat

You get

Prioritisation backed by counts instead of instinct. It sweeps the shared workspace view rather than one thread, matches on the symptom you described, and reports how many distinct conversations mention it and when the first one arrived. Two reports in a month reads very differently from nine in two days.

You ask

“Pull the log the customer pasted so I can reproduce it locally.”

Tools called

entergram_list_chatsentergram_list_messagesentergram_get_message

You get

The agent locates the thread, walks back to the message carrying the payload, and fetches it in full rather than the truncated preview. From there you can ask it to turn the log into a failing test in the file you already have open, which is the part that is genuinely faster than reading Telegram on a second screen.

You ask

“Paste these reproduction steps onto the ticket for this bug.”

Tools called

entergram_list_ticketsentergram_get_ticketentergram_create_ticket_comment

You get

Your notes land where the support team will look for them, written while the context is still in your head. The comment is attached to the ticket rather than sent to the customer, so an engineer can be blunt about the cause without anyone drafting a diplomatic version of it first.

You ask

“Which plan is the person who filed this on, and what have we already told them?”

Tools called

entergram_list_custom_columnsentergram_get_chat_custom_fieldsentergram_list_chat_comments

You get

It reads your column schema, pulls the values set on that chat, and then reads the internal notes your teammates left on it. The answer arrives as one paragraph: their tier, their renewal state if you track it, and the commitment someone made on a call last week that you were never told about.

You ask

“The fix is merged. Tell the two people who reported it and close the ticket.”

Tools called

entergram_list_accountsentergram_send_messageentergram_update_ticket

You get

The step everyone skips. It resolves which connected account owns each conversation, sends a short note per reporter for you to approve, and moves the ticket to closed once they are out. The loop between shipping and telling the affected customer collapses from a to-do into one prompt.

What your editor can do with Telegram

  • Read the bug report next to the code that caused it
  • Reach the reporter without leaving the editor
  • Check whether an issue has more than one complainant
  • Attach a chat to a ticket while the fix is fresh
  • Works the same in Cursor, Zed and Windsurf
  • Keep customer context in the same window as the diff

The 70 tools your editor picks up

Cursor, Zed and Windsurf all receive the same list — nine groups, seventy named functions — and each of them prints the calls as the agent makes them, so you can watch a question turn into a sequence and interrupt it early. Which of the seventy actually succeed depends on the access level behind the grant, described below.

Accounts & workspace

5 tools

Identity and scope discovery. Every message call needs an account_id from list_accounts first — an AI client that skips this step will address the wrong Telegram account.

  • entergram_get_me
  • entergram_list_accounts
  • entergram_get_workspace
  • entergram_get_member
  • entergram_list_members

Chats & discovery

8 tools

Finding conversations. The workspace views carry CRM state (tickets, comments, custom fields); the live views carry current Telegram transport state and unread counts.

  • entergram_list_chats
  • entergram_get_chat
  • entergram_list_live_chats
  • entergram_get_live_chat
  • entergram_list_workspace_chats
  • entergram_get_workspace_chat
  • entergram_update_workspace_chat
  • entergram_get_chat_management

Messages

9 tools

Reading and writing message history, including edits, forwards and reactions. Sending is scoped per account, so nothing is global across your connected accounts.

  • entergram_list_messages
  • entergram_get_message
  • entergram_send_message
  • entergram_send_media_message
  • entergram_edit_message
  • entergram_delete_message
  • entergram_forward_messages
  • entergram_get_message_reactions
  • entergram_set_message_reactions

Contacts

3 tools

Who you are talking to, and where else you overlap with them. Shared-groups lookup is what makes questions like “which of my leads are in the same community?” answerable.

  • entergram_list_contacts
  • entergram_get_contact
  • entergram_list_contact_shared_groups

Tickets

10 tools

Full support-desk control: open, assign, prioritise, comment and close. Tickets link back to the chat they came from, so an AI client can move from conversation to queue in one step.

  • entergram_list_tickets
  • entergram_get_ticket
  • entergram_create_ticket
  • entergram_update_ticket
  • entergram_delete_ticket
  • entergram_list_chat_tickets
  • entergram_list_ticket_comments
  • entergram_create_ticket_comment
  • entergram_update_ticket_comment
  • entergram_delete_ticket_comment

CRM custom fields

11 tools

Your pipeline schema. Read the columns before writing values — checkboxes take booleans, multiselects take arrays of option values, dates take ISO 8601 strings.

  • entergram_list_custom_columns
  • entergram_get_custom_column
  • entergram_create_custom_column
  • entergram_update_custom_column
  • entergram_delete_custom_column
  • entergram_list_custom_column_options
  • entergram_create_custom_column_option
  • entergram_update_custom_column_option
  • entergram_delete_custom_column_option
  • entergram_get_chat_custom_fields
  • entergram_patch_chat_custom_fields

Ticket custom fields

9 tools

The same schema control for the ticket side — categories, severities, SLA tiers and anything else your desk tracks beyond status and priority.

  • entergram_list_ticket_custom_columns
  • entergram_get_ticket_custom_column
  • entergram_create_ticket_custom_column
  • entergram_update_ticket_custom_column
  • entergram_delete_ticket_custom_column
  • entergram_list_ticket_custom_column_options
  • entergram_create_ticket_custom_column_option
  • entergram_update_ticket_custom_column_option
  • entergram_delete_ticket_custom_column_option

Internal notes

4 tools

Comments on a chat that your customer never sees. Useful for letting an AI client leave its reasoning behind for a human teammate to pick up.

  • entergram_list_chat_comments
  • entergram_create_chat_comment
  • entergram_update_chat_comment
  • entergram_delete_chat_comment

Groups & channels

11 tools

Creating and administering Telegram groups and channels — membership, permissions, privacy and info — plus a raw command escape hatch for the rest.

  • entergram_list_groups
  • entergram_get_group
  • entergram_list_group_members
  • entergram_create_group_chat
  • entergram_create_channel
  • entergram_invite_chat_members
  • entergram_remove_chat_member
  • entergram_update_chat_info
  • entergram_update_chat_permissions
  • entergram_update_chat_privacy
  • entergram_run_chat_command

What lives in the config file, and what doesn't

The entry you paste into mcp.json holds exactly one thing: an address. No token, no phone number, no API key, which is why a project-level .cursor/mcp.json is safe to commit next to the code it serves. The grant itself is made in a browser, belongs to you rather than to the repository, and is stored by the editor. To take it back, revoke the connection from the MCP screen under Settings → Workspace → Connectors in Entergram; the token the editor is holding stops working on its next call. Two access levels exist and they are not interchangeable.

Personal agent
Any member can issue one for themselves, and on a development laptop it is usually the right ceiling. It reads across workspace, accounts, contacts, chats, messages and tickets, and writes only the custom fields on chats belonging to your own connected accounts. An agent holding this can research a bug exhaustively and cannot message the person who reported it.
Workspace connector
Reserved for owners and admins. It carries the whole scope set — sending, writing custom fields on any chat, group administration — and it is shared with the team rather than owned by one developer. Use it when the editor is doing work on behalf of the company rather than on behalf of you.
Revocation
Works from either end and takes effect at once. Deleting the server from mcp.json stops the editor asking; revoking in Entergram stops it being answered. The second is the one that matters when the laptop is no longer in your hands.

Where the editor integration stops

Worth knowing before you build a habit around it.

  • MCP access sits on the Pro plan, and nothing on the editor side changes that — a workspace below it can register the server, complete the login, and still get nothing useful back from a call.
  • Nothing arrives on its own. The editor queries Entergram only inside a turn you started, so a message that lands while you are mid-refactor waits quietly until you next ask about it.
  • Config is per machine. mcp.json does not travel with your editor account, and neither does the OAuth grant — a second laptop means a second file and a second consent screen.
  • Tool output stays in the conversation. The agent can quote a customer's log into a comment or a fixture, but it writes to your files only when you ask it to, and never in the other direction.
  • Every send names one account. account_id is a required argument rather than a default, so an agent that picks the wrong branch cannot also improvise its way into messaging your entire contact list.
  • The connector sees precisely what your Telegram account sees. A group you were never added to stays invisible from the editor too, however the prompt is phrased.

When the editor won't see Entergram

The server shows a red dot in Cursor's MCP panel
Cursor caches the tool list from the last successful handshake. Toggle the server off and on under Cursor Settings → MCP & Integrations, and if the dot stays red, reload the window — the agent reads the list when the window boots, not when you edit the file.
Zed ignores the entry entirely
You almost certainly wrote mcpServers. Zed's key is context_servers, and an unrecognised top-level key is dropped silently rather than reported as an error. Correct the key name, save, and restart Zed.
Windsurf shows no Entergram tools after saving
Confirm you edited ~/.codeium/windsurf/mcp_config.json rather than the settings UI, then open the MCP panel in Cascade and refresh it. Windsurf re-reads that file when asked and not before.
The consent screen opens but the editor stays disconnected
Authorization finishes in whichever browser your operating system opens by default. Complete the login there while signed in to Entergram in that same profile, then come back and trigger the connect action once more.
The agent answers about Telegram without calling anything
Too many servers are registered and the tool list is being trimmed before the model sees it. Disable the MCP servers you are not using for this task and name Entergram in the prompt so the choice is unambiguous.
Calls come back 403
Check two things in order. Your role: a workspace connector needs owner or admin, and a personal agent covers everyone else. Then your plan: MCP access lives on Pro, and a lower tier fails here rather than at connect time.

Cursor / Zed / Windsurf + Telegram FAQ

Which editors are supported?
Any editor that supports MCP via mcp.json — including Cursor, Zed and Windsurf. Register the Entergram MCP URL and authorize via OAuth.
Is this a Telegram bot?
No. A bot would be a second account your customers can tell apart. This is your own account, reached through a hosted MCP server, so replies come from you.
Can it tell me what I missed while coding?
Yes. Ask your editor’s AI and it will read your chats, count unanswered messages and flag the ones from clients.
Is it secure?
Yes. Authorization is OAuth 2.0 with scoped permissions. Your Telegram session stays inside Entergram — it is never written into mcp.json or synced with your editor settings — and you can revoke the connector at any time.

Cursor Telegram MCP — Telegram in Cursor, Zed & Windsurf