akougkas.io

ZulipChat MCP

An MCP server for agent participation in Zulip conversations.

An MCP server that connects an agent to Zulip streams, topics, and people. It is released on PyPI with a focused core tool set and an extended mode for less frequent operations.

Install from PyPI View the code

Agent access to Zulip

  1. Agent session

    An MCP-capable client asks for a conversation.

  2. ZulipChat MCP

    Tools expose reading, searching, and participation.

  3. Streams and topics

    Messages stay attached to their discussion context.

The MCP server connects an agent to Zulip’s streams, topics, and people, and keeps each message attached to the discussion it belongs to.

The question

Team chat contains more than messages. It carries decisions, unfinished work, names, norms, and the moment when someone says “yes, do that.” If an agent is going to participate, how can it join the conversation without flattening all of that into a generic send-message function?

ZulipChat MCP began as a practical tool for my own work: connect an MCP-capable agent to Zulip, make streams and topics understandable, and remove the repetitive glue required to search a discussion or continue a long-running task. The deeper problem appeared as soon as the first message could be sent. Messaging is an action, and actions need identity, scope, and a visible path back to the person responsible.

The product bet

The bet is that a useful integration should feel small at the point of use while remaining explicit underneath. A person should be able to ask for a conversation, resolve a colleague by name, or attach an agent session to a topic. The implementation still has to preserve Zulip’s structure and make consequential actions recognizable.

Since v0.7.2, the package exposes a focused core tool set for common work and an extended mode for less frequent operations. Giving a model every available operation at once adds selection cost and makes the authority surface harder to read, so the default stays small.

v0.7.6 came from watching an agent use the server. In a run of CLIO Coder against a live Zulip organization, a local model repeated messages that had already gone through and posted as the user while presenting itself as the bot, and anyone in the organization could steer a watcher on my machine by mentioning the bot. The release admits only the owner to the bot’s inbox by default, never returns the bot’s own messages as new work, suppresses an identical repeat of a send that already succeeded, and annotates every tool as read-only, destructive, or idempotent.

What shipped

The project is available as a versioned Python package and a public GitHub release. The repository includes onboarding, integration guides, tests, continuous integration, a security policy, and an explicit privacy statement. It supports reading and searching conversations, participating in messages, resolving people and topics, and binding an agent session to a stable discussion context.

Those artifacts matter more to me than a feature list. Packaging asks whether a stranger can install the tool. Tests ask which behavior I am willing to name precisely. Documentation exposes where the abstraction is awkward. A privacy statement forces the data path to be explained in language a user can challenge.

My part, and the open-source edge

I created the project and remain its maintainer. The work has been hands-on: API behavior, tool boundaries, session semantics, setup, packaging, documentation, and the unglamorous diagnosis paths that determine whether an integration is usable. Public contributors have also improved the repository, and Zulip’s own open API and conversational model provide the foundation the tool builds upon.

This is the kind of entrepreneurial work I enjoy: notice friction in a workflow I use every day, build the smallest credible product, put it where someone else can run it, and let use reveal the next design problem. It does not need to become a startup pitch to exercise product judgment.

The boundary

ZulipChat MCP is pre-1.0 software. It does not make an agent trustworthy, and it does not replace the permissions, retention rules, or operating policy of the Zulip deployment it connects to. Reading, sending, editing, and identity switching have different consequences even when they share one protocol.

The project therefore stays conservative about what is enabled by default. Credentials remain an installation responsibility, sensitive conversations still require human judgment, and an approval interaction is useful only when the surrounding team understands what it authorizes.

What I am learning

  • Tool selection is an interface-design problem before it is an API problem.
  • Approvals work best when they remain inside the conversation that created the request.
  • A stable topic can give an agent continuity without pretending the model itself has durable memory.
  • Interoperability becomes valuable when the integration preserves the host system’s social structure instead of hiding it.

Code, releases, papers, and records

  1. code

    ZulipChat MCP repository

    The implementation, documentation, tests, security policy, and public development history.

  2. release

    ZulipChat MCP v0.7.6, October 9, 2026

    Limits the bot inbox to the owner by default and suppresses repeated sends, after a run of CLIO Coder against a live Zulip organization showed a local model repeating sends and posting as the user.

  3. package

    ZulipChat MCP on PyPI

    The installable Python package and its versioned distribution record.

Related notes

  1. essay

    MCP for science: what sixteen servers taught us

    CLIO Kit ships sixteen MCP servers over scientific formats, schedulers, and a shared log. What they taught us about tool shapes, what a summarize tool must refuse, and where the protocol runs out.

    9 min
  • 2023–present

    CLIO Coder

    A local-first coding agent with typed tools, bounded workers, and receipts.